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

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

@@ -1,224 +0,0 @@
-use super::plumbing::*;
-use super::*;
-use crate::math::div_round_up;
-
-/// `Chunks` is an iterator that groups elements of an underlying iterator.
-///
-/// This struct is created by the [`chunks()`] method on [`IndexedParallelIterator`]
-///
-/// [`chunks()`]: trait.IndexedParallelIterator.html#method.chunks
-/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
-#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-#[derive(Debug, Clone)]
-pub struct Chunks<I>
-where
-    I: IndexedParallelIterator,
-{
-    size: usize,
-    i: I,
-}
-
-impl<I> Chunks<I>
-where
-    I: IndexedParallelIterator,
-{
-    /// Creates a new `Chunks` iterator
-    pub(super) fn new(i: I, size: usize) -> Self {
-        Chunks { i, size }
-    }
-}
-
-impl<I> ParallelIterator for Chunks<I>
-where
-    I: IndexedParallelIterator,
-{
-    type Item = Vec<I::Item>;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: Consumer<Vec<I::Item>>,
-    {
-        bridge(self, consumer)
-    }
-
-    fn opt_len(&self) -> Option<usize> {
-        Some(self.len())
-    }
-}
-
-impl<I> IndexedParallelIterator for Chunks<I>
-where
-    I: IndexedParallelIterator,
-{
-    fn drive<C>(self, consumer: C) -> C::Result
-    where
-        C: Consumer<Self::Item>,
-    {
-        bridge(self, consumer)
-    }
-
-    fn len(&self) -> usize {
-        div_round_up(self.i.len(), self.size)
-    }
-
-    fn with_producer<CB>(self, callback: CB) -> CB::Output
-    where
-        CB: ProducerCallback<Self::Item>,
-    {
-        let len = self.i.len();
-        return self.i.with_producer(Callback {
-            size: self.size,
-            len,
-            callback,
-        });
-
-        struct Callback<CB> {
-            size: usize,
-            len: usize,
-            callback: CB,
-        }
-
-        impl<T, CB> ProducerCallback<T> for Callback<CB>
-        where
-            CB: ProducerCallback<Vec<T>>,
-        {
-            type Output = CB::Output;
-
-            fn callback<P>(self, base: P) -> CB::Output
-            where
-                P: Producer<Item = T>,
-            {
-                let producer = ChunkProducer::new(self.size, self.len, base, Vec::from_iter);
-                self.callback.callback(producer)
-            }
-        }
-    }
-}
-
-pub(super) struct ChunkProducer<P, F> {
-    chunk_size: usize,
-    len: usize,
-    base: P,
-    map: F,
-}
-
-impl<P, F> ChunkProducer<P, F> {
-    pub(super) fn new(chunk_size: usize, len: usize, base: P, map: F) -> Self {
-        Self {
-            chunk_size,
-            len,
-            base,
-            map,
-        }
-    }
-}
-
-impl<P, F, T> Producer for ChunkProducer<P, F>
-where
-    P: Producer,
-    F: Fn(P::IntoIter) -> T + Send + Clone,
-{
-    type Item = T;
-    type IntoIter = std::iter::Map<ChunkSeq<P>, F>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        let chunks = ChunkSeq {
-            chunk_size: self.chunk_size,
-            len: self.len,
-            inner: if self.len > 0 { Some(self.base) } else { None },
-        };
-        chunks.map(self.map)
-    }
-
-    fn split_at(self, index: usize) -> (Self, Self) {
-        let elem_index = Ord::min(index * self.chunk_size, self.len);
-        let (left, right) = self.base.split_at(elem_index);
-        (
-            ChunkProducer {
-                chunk_size: self.chunk_size,
-                len: elem_index,
-                base: left,
-                map: self.map.clone(),
-            },
-            ChunkProducer {
-                chunk_size: self.chunk_size,
-                len: self.len - elem_index,
-                base: right,
-                map: self.map,
-            },
-        )
-    }
-
-    fn min_len(&self) -> usize {
-        div_round_up(self.base.min_len(), self.chunk_size)
-    }
-
-    fn max_len(&self) -> usize {
-        self.base.max_len() / self.chunk_size
-    }
-}
-
-pub(super) struct ChunkSeq<P> {
-    chunk_size: usize,
-    len: usize,
-    inner: Option<P>,
-}
-
-impl<P> Iterator for ChunkSeq<P>
-where
-    P: Producer,
-{
-    type Item = P::IntoIter;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let producer = self.inner.take()?;
-        if self.len > self.chunk_size {
-            let (left, right) = producer.split_at(self.chunk_size);
-            self.inner = Some(right);
-            self.len -= self.chunk_size;
-            Some(left.into_iter())
-        } else {
-            debug_assert!(self.len > 0);
-            self.len = 0;
-            Some(producer.into_iter())
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.len();
-        (len, Some(len))
-    }
-}
-
-impl<P> ExactSizeIterator for ChunkSeq<P>
-where
-    P: Producer,
-{
-    #[inline]
-    fn len(&self) -> usize {
-        div_round_up(self.len, self.chunk_size)
-    }
-}
-
-impl<P> DoubleEndedIterator for ChunkSeq<P>
-where
-    P: Producer,
-{
-    fn next_back(&mut self) -> Option<Self::Item> {
-        let producer = self.inner.take()?;
-        if self.len > self.chunk_size {
-            let mut size = self.len % self.chunk_size;
-            if size == 0 {
-                size = self.chunk_size;
-            }
-            let (left, right) = producer.split_at(self.len - size);
-            self.inner = Some(left);
-            self.len -= size;
-            Some(right.into_iter())
-        } else {
-            debug_assert!(self.len > 0);
-            self.len = 0;
-            Some(producer.into_iter())
-        }
-    }
-}

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

@@ -1,223 +0,0 @@
-use super::plumbing::*;
-use super::*;
-
-use std::iter;
-
-/// `Cloned` is an iterator that clones the elements of an underlying iterator.
-///
-/// This struct is created by the [`cloned()`] method on [`ParallelIterator`]
-///
-/// [`cloned()`]: trait.ParallelIterator.html#method.cloned
-/// [`ParallelIterator`]: trait.ParallelIterator.html
-#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-#[derive(Debug, Clone)]
-pub struct Cloned<I: ParallelIterator> {
-    base: I,
-}
-
-impl<I> Cloned<I>
-where
-    I: ParallelIterator,
-{
-    /// Creates a new `Cloned` iterator.
-    pub(super) fn new(base: I) -> Self {
-        Cloned { base }
-    }
-}
-
-impl<'a, T, I> ParallelIterator for Cloned<I>
-where
-    I: ParallelIterator<Item = &'a T>,
-    T: 'a + Clone + Send + Sync,
-{
-    type Item = T;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        let consumer1 = ClonedConsumer::new(consumer);
-        self.base.drive_unindexed(consumer1)
-    }
-
-    fn opt_len(&self) -> Option<usize> {
-        self.base.opt_len()
-    }
-}
-
-impl<'a, T, I> IndexedParallelIterator for Cloned<I>
-where
-    I: IndexedParallelIterator<Item = &'a T>,
-    T: 'a + Clone + Send + Sync,
-{
-    fn drive<C>(self, consumer: C) -> C::Result
-    where
-        C: Consumer<Self::Item>,
-    {
-        let consumer1 = ClonedConsumer::new(consumer);
-        self.base.drive(consumer1)
-    }
-
-    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 });
-
-        struct Callback<CB> {
-            callback: CB,
-        }
-
-        impl<'a, T, CB> ProducerCallback<&'a T> for Callback<CB>
-        where
-            CB: ProducerCallback<T>,
-            T: 'a + Clone + Send,
-        {
-            type Output = CB::Output;
-
-            fn callback<P>(self, base: P) -> CB::Output
-            where
-                P: Producer<Item = &'a T>,
-            {
-                let producer = ClonedProducer { base };
-                self.callback.callback(producer)
-            }
-        }
-    }
-}
-
-/// ////////////////////////////////////////////////////////////////////////
-
-struct ClonedProducer<P> {
-    base: P,
-}
-
-impl<'a, T, P> Producer for ClonedProducer<P>
-where
-    P: Producer<Item = &'a T>,
-    T: 'a + Clone,
-{
-    type Item = T;
-    type IntoIter = iter::Cloned<P::IntoIter>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.base.into_iter().cloned()
-    }
-
-    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) {
-        let (left, right) = self.base.split_at(index);
-        (
-            ClonedProducer { base: left },
-            ClonedProducer { base: right },
-        )
-    }
-
-    fn fold_with<F>(self, folder: F) -> F
-    where
-        F: Folder<Self::Item>,
-    {
-        self.base.fold_with(ClonedFolder { base: folder }).base
-    }
-}
-
-/// ////////////////////////////////////////////////////////////////////////
-/// Consumer implementation
-
-struct ClonedConsumer<C> {
-    base: C,
-}
-
-impl<C> ClonedConsumer<C> {
-    fn new(base: C) -> Self {
-        ClonedConsumer { base }
-    }
-}
-
-impl<'a, T, C> Consumer<&'a T> for ClonedConsumer<C>
-where
-    C: Consumer<T>,
-    T: 'a + Clone,
-{
-    type Folder = ClonedFolder<C::Folder>;
-    type Reducer = C::Reducer;
-    type Result = C::Result;
-
-    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
-        let (left, right, reducer) = self.base.split_at(index);
-        (
-            ClonedConsumer::new(left),
-            ClonedConsumer::new(right),
-            reducer,
-        )
-    }
-
-    fn into_folder(self) -> Self::Folder {
-        ClonedFolder {
-            base: self.base.into_folder(),
-        }
-    }
-
-    fn full(&self) -> bool {
-        self.base.full()
-    }
-}
-
-impl<'a, T, C> UnindexedConsumer<&'a T> for ClonedConsumer<C>
-where
-    C: UnindexedConsumer<T>,
-    T: 'a + Clone,
-{
-    fn split_off_left(&self) -> Self {
-        ClonedConsumer::new(self.base.split_off_left())
-    }
-
-    fn to_reducer(&self) -> Self::Reducer {
-        self.base.to_reducer()
-    }
-}
-
-struct ClonedFolder<F> {
-    base: F,
-}
-
-impl<'a, T, F> Folder<&'a T> for ClonedFolder<F>
-where
-    F: Folder<T>,
-    T: 'a + Clone,
-{
-    type Result = F::Result;
-
-    fn consume(self, item: &'a T) -> Self {
-        ClonedFolder {
-            base: self.base.consume(item.clone()),
-        }
-    }
-
-    fn consume_iter<I>(mut self, iter: I) -> Self
-    where
-        I: IntoIterator<Item = &'a T>,
-    {
-        self.base = self.base.consume_iter(iter.into_iter().cloned());
-        self
-    }
-
-    fn complete(self) -> F::Result {
-        self.base.complete()
-    }
-
-    fn full(&self) -> bool {
-        self.base.full()
-    }
-}

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

@@ -1,116 +0,0 @@
-use super::{IndexedParallelIterator, ParallelIterator};
-
-mod consumer;
-use self::consumer::CollectConsumer;
-use self::consumer::CollectResult;
-use super::unzip::unzip_indexed;
-
-mod test;
-
-/// Collects the results of the exact iterator into the specified vector.
-///
-/// This is called by `IndexedParallelIterator::collect_into_vec`.
-pub(super) fn collect_into_vec<I, T>(pi: I, v: &mut Vec<T>)
-where
-    I: IndexedParallelIterator<Item = T>,
-    T: Send,
-{
-    v.truncate(0); // clear any old data
-    let len = pi.len();
-    collect_with_consumer(v, len, |consumer| pi.drive(consumer));
-}
-
-/// Collects the results of the iterator into the specified vector.
-///
-/// Technically, this only works for `IndexedParallelIterator`, but we're faking a
-/// bit of specialization here until Rust can do that natively.  Callers are
-/// using `opt_len` to find the length before calling this, and only exact
-/// iterators will return anything but `None` there.
-///
-/// Since the type system doesn't understand that contract, we have to allow
-/// *any* `ParallelIterator` here, and `CollectConsumer` has to also implement
-/// `UnindexedConsumer`.  That implementation panics `unreachable!` in case
-/// there's a bug where we actually do try to use this unindexed.
-pub(super) fn special_extend<I, T>(pi: I, len: usize, v: &mut Vec<T>)
-where
-    I: ParallelIterator<Item = T>,
-    T: Send,
-{
-    collect_with_consumer(v, len, |consumer| pi.drive_unindexed(consumer));
-}
-
-/// Unzips the results of the exact iterator into the specified vectors.
-///
-/// This is called by `IndexedParallelIterator::unzip_into_vecs`.
-pub(super) fn unzip_into_vecs<I, A, B>(pi: I, left: &mut Vec<A>, right: &mut Vec<B>)
-where
-    I: IndexedParallelIterator<Item = (A, B)>,
-    A: Send,
-    B: Send,
-{
-    // clear any old data
-    left.truncate(0);
-    right.truncate(0);
-
-    let len = pi.len();
-    collect_with_consumer(right, len, |right_consumer| {
-        let mut right_result = None;
-        collect_with_consumer(left, len, |left_consumer| {
-            let (left_r, right_r) = unzip_indexed(pi, left_consumer, right_consumer);
-            right_result = Some(right_r);
-            left_r
-        });
-        right_result.unwrap()
-    });
-}
-
-/// Create a consumer on the slice of memory we are collecting into.
-///
-/// The consumer needs to be used inside the scope function, and the
-/// complete collect result passed back.
-///
-/// This method will verify the collect result, and panic if the slice
-/// was not fully written into. Otherwise, in the successful case,
-/// the vector is complete with the collected result.
-fn collect_with_consumer<T, F>(vec: &mut Vec<T>, len: usize, scope_fn: F)
-where
-    T: Send,
-    F: FnOnce(CollectConsumer<'_, T>) -> CollectResult<'_, T>,
-{
-    // Reserve space for `len` more elements in the vector,
-    vec.reserve(len);
-
-    // Create the consumer and run the callback for collection.
-    let result = scope_fn(CollectConsumer::appender(vec, len));
-
-    // The `CollectResult` represents a contiguous part of the slice, that has
-    // been written to. On unwind here, the `CollectResult` will be dropped. If
-    // some producers on the way did not produce enough elements, partial
-    // `CollectResult`s may have been dropped without being reduced to the final
-    // result, and we will see that as the length coming up short.
-    //
-    // Here, we assert that added length is fully initialized. This is checked
-    // by the following assert, which verifies if a complete `CollectResult`
-    // was produced; if the length is correct, it is necessarily covering the
-    // target slice. Since we know that the consumer cannot have escaped from
-    // `drive` (by parametricity, essentially), we know that any stores that
-    // will happen, have happened. Unless some code is buggy, that means we
-    // should have seen `len` total writes.
-    let actual_writes = result.len();
-    assert!(
-        actual_writes == len,
-        "expected {} total writes, but got {}",
-        len,
-        actual_writes
-    );
-
-    // Release the result's mutable borrow and "proxy ownership"
-    // of the elements, before the vector takes it over.
-    result.release_ownership();
-
-    let new_len = vec.len() + len;
-
-    unsafe {
-        vec.set_len(new_len);
-    }
-}