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

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

@@ -1,158 +0,0 @@
-use super::plumbing::*;
-use super::*;
-use std::iter;
-
-/// `Zip` is an iterator that zips up `a` and `b` into a single iterator
-/// of pairs. This struct is created by the [`zip()`] method on
-/// [`IndexedParallelIterator`]
-///
-/// [`zip()`]: trait.IndexedParallelIterator.html#method.zip
-/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
-#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-#[derive(Debug, Clone)]
-pub struct Zip<A: IndexedParallelIterator, B: IndexedParallelIterator> {
-    a: A,
-    b: B,
-}
-
-impl<A, B> Zip<A, B>
-where
-    A: IndexedParallelIterator,
-    B: IndexedParallelIterator,
-{
-    /// Creates a new `Zip` iterator.
-    pub(super) fn new(a: A, b: B) -> Self {
-        Zip { a, b }
-    }
-}
-
-impl<A, B> ParallelIterator for Zip<A, B>
-where
-    A: IndexedParallelIterator,
-    B: IndexedParallelIterator,
-{
-    type Item = (A::Item, B::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<A, B> IndexedParallelIterator for Zip<A, B>
-where
-    A: IndexedParallelIterator,
-    B: IndexedParallelIterator,
-{
-    fn drive<C>(self, consumer: C) -> C::Result
-    where
-        C: Consumer<Self::Item>,
-    {
-        bridge(self, consumer)
-    }
-
-    fn len(&self) -> usize {
-        Ord::min(self.a.len(), self.b.len())
-    }
-
-    fn with_producer<CB>(self, callback: CB) -> CB::Output
-    where
-        CB: ProducerCallback<Self::Item>,
-    {
-        return self.a.with_producer(CallbackA {
-            callback,
-            b: self.b,
-        });
-
-        struct CallbackA<CB, B> {
-            callback: CB,
-            b: B,
-        }
-
-        impl<CB, ITEM, B> ProducerCallback<ITEM> for CallbackA<CB, B>
-        where
-            B: IndexedParallelIterator,
-            CB: ProducerCallback<(ITEM, B::Item)>,
-        {
-            type Output = CB::Output;
-
-            fn callback<A>(self, a_producer: A) -> Self::Output
-            where
-                A: Producer<Item = ITEM>,
-            {
-                self.b.with_producer(CallbackB {
-                    a_producer,
-                    callback: self.callback,
-                })
-            }
-        }
-
-        struct CallbackB<CB, A> {
-            a_producer: A,
-            callback: CB,
-        }
-
-        impl<CB, A, ITEM> ProducerCallback<ITEM> for CallbackB<CB, A>
-        where
-            A: Producer,
-            CB: ProducerCallback<(A::Item, ITEM)>,
-        {
-            type Output = CB::Output;
-
-            fn callback<B>(self, b_producer: B) -> Self::Output
-            where
-                B: Producer<Item = ITEM>,
-            {
-                self.callback.callback(ZipProducer {
-                    a: self.a_producer,
-                    b: b_producer,
-                })
-            }
-        }
-    }
-}
-
-/// ////////////////////////////////////////////////////////////////////////
-
-struct ZipProducer<A: Producer, B: Producer> {
-    a: A,
-    b: B,
-}
-
-impl<A: Producer, B: Producer> Producer for ZipProducer<A, B> {
-    type Item = (A::Item, B::Item);
-    type IntoIter = iter::Zip<A::IntoIter, B::IntoIter>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.a.into_iter().zip(self.b.into_iter())
-    }
-
-    fn min_len(&self) -> usize {
-        Ord::max(self.a.min_len(), self.b.min_len())
-    }
-
-    fn max_len(&self) -> usize {
-        Ord::min(self.a.max_len(), self.b.max_len())
-    }
-
-    fn split_at(self, index: usize) -> (Self, Self) {
-        let (a_left, a_right) = self.a.split_at(index);
-        let (b_left, b_right) = self.b.split_at(index);
-        (
-            ZipProducer {
-                a: a_left,
-                b: b_left,
-            },
-            ZipProducer {
-                a: a_right,
-                b: b_right,
-            },
-        )
-    }
-}

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

@@ -1,72 +0,0 @@
-use super::plumbing::*;
-use super::*;
-
-/// An [`IndexedParallelIterator`] that iterates over two parallel iterators of equal
-/// length simultaneously.
-///
-/// This struct is created by the [`zip_eq`] method on [`IndexedParallelIterator`],
-/// see its documentation for more information.
-///
-/// [`zip_eq`]: trait.IndexedParallelIterator.html#method.zip_eq
-/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
-#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-#[derive(Debug, Clone)]
-pub struct ZipEq<A: IndexedParallelIterator, B: IndexedParallelIterator> {
-    zip: Zip<A, B>,
-}
-
-impl<A, B> ZipEq<A, B>
-where
-    A: IndexedParallelIterator,
-    B: IndexedParallelIterator,
-{
-    /// Creates a new `ZipEq` iterator.
-    pub(super) fn new(a: A, b: B) -> Self {
-        ZipEq {
-            zip: super::Zip::new(a, b),
-        }
-    }
-}
-
-impl<A, B> ParallelIterator for ZipEq<A, B>
-where
-    A: IndexedParallelIterator,
-    B: IndexedParallelIterator,
-{
-    type Item = (A::Item, B::Item);
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        bridge(self.zip, consumer)
-    }
-
-    fn opt_len(&self) -> Option<usize> {
-        Some(self.zip.len())
-    }
-}
-
-impl<A, B> IndexedParallelIterator for ZipEq<A, B>
-where
-    A: IndexedParallelIterator,
-    B: IndexedParallelIterator,
-{
-    fn drive<C>(self, consumer: C) -> C::Result
-    where
-        C: Consumer<Self::Item>,
-    {
-        bridge(self.zip, consumer)
-    }
-
-    fn len(&self) -> usize {
-        self.zip.len()
-    }
-
-    fn with_producer<CB>(self, callback: CB) -> CB::Output
-    where
-        CB: ProducerCallback<Self::Item>,
-    {
-        self.zip.with_producer(callback)
-    }
-}

data/ext/cargo-vendor/rayon-1.10.0/src/lib.rs

@@ -1,160 +0,0 @@
-#![deny(missing_debug_implementations)]
-#![deny(missing_docs)]
-#![deny(unreachable_pub)]
-#![warn(rust_2018_idioms)]
-
-//! Rayon is a data-parallelism library that makes it easy to convert sequential
-//! computations into parallel.
-//!
-//! It is lightweight and convenient for introducing parallelism into existing
-//! code. It guarantees data-race free executions and takes advantage of
-//! parallelism when sensible, based on work-load at runtime.
-//!
-//! # How to use Rayon
-//!
-//! There are two ways to use Rayon:
-//!
-//! - **High-level parallel constructs** are the simplest way to use Rayon and also
-//!   typically the most efficient.
-//!   - [Parallel iterators][iter module] make it easy to convert a sequential iterator to
-//!     execute in parallel.
-//!     - The [`ParallelIterator`] trait defines general methods for all parallel iterators.
-//!     - The [`IndexedParallelIterator`] trait adds methods for iterators that support random
-//!       access.
-//!   - The [`par_sort`] method sorts `&mut [T]` slices (or vectors) in parallel.
-//!   - [`par_extend`] can be used to efficiently grow collections with items produced
-//!     by a parallel iterator.
-//! - **Custom tasks** let you divide your work into parallel tasks yourself.
-//!   - [`join`] is used to subdivide a task into two pieces.
-//!   - [`scope`] creates a scope within which you can create any number of parallel tasks.
-//!   - [`ThreadPoolBuilder`] can be used to create your own thread pools or customize
-//!     the global one.
-//!
-//! [iter module]: iter/index.html
-//! [`join`]: fn.join.html
-//! [`scope`]: fn.scope.html
-//! [`par_sort`]: slice/trait.ParallelSliceMut.html#method.par_sort
-//! [`par_extend`]: iter/trait.ParallelExtend.html#tymethod.par_extend
-//! [`ThreadPoolBuilder`]: struct.ThreadPoolBuilder.html
-//!
-//! # Basic usage and the Rayon prelude
-//!
-//! First, you will need to add `rayon` to your `Cargo.toml`.
-//!
-//! Next, to use parallel iterators or the other high-level methods,
-//! you need to import several traits. Those traits are bundled into
-//! the module [`rayon::prelude`]. It is recommended that you import
-//! all of these traits at once by adding `use rayon::prelude::*` at
-//! the top of each module that uses Rayon methods.
-//!
-//! These traits give you access to the `par_iter` method which provides
-//! parallel implementations of many iterative functions such as [`map`],
-//! [`for_each`], [`filter`], [`fold`], and [more].
-//!
-//! [`rayon::prelude`]: prelude/index.html
-//! [`map`]: iter/trait.ParallelIterator.html#method.map
-//! [`for_each`]: iter/trait.ParallelIterator.html#method.for_each
-//! [`filter`]: iter/trait.ParallelIterator.html#method.filter
-//! [`fold`]: iter/trait.ParallelIterator.html#method.fold
-//! [more]: iter/trait.ParallelIterator.html#provided-methods
-//! [`ParallelIterator`]: iter/trait.ParallelIterator.html
-//! [`IndexedParallelIterator`]: iter/trait.IndexedParallelIterator.html
-//!
-//! # Crate Layout
-//!
-//! Rayon extends many of the types found in the standard library with
-//! parallel iterator implementations. The modules in the `rayon`
-//! crate mirror [`std`] itself: so, e.g., the `option` module in
-//! Rayon contains parallel iterators for the `Option` type, which is
-//! found in [the `option` module of `std`]. Similarly, the
-//! `collections` module in Rayon offers parallel iterator types for
-//! [the `collections` from `std`]. You will rarely need to access
-//! these submodules unless you need to name iterator types
-//! explicitly.
-//!
-//! [the `option` module of `std`]: https://doc.rust-lang.org/std/option/index.html
-//! [the `collections` from `std`]: https://doc.rust-lang.org/std/collections/index.html
-//! [`std`]: https://doc.rust-lang.org/std/
-//!
-//! # Targets without threading
-//!
-//! Rayon has limited support for targets without `std` threading implementations.
-//! See the [`rayon_core`] documentation for more information about its global fallback.
-//!
-//! # Other questions?
-//!
-//! See [the Rayon FAQ][faq].
-//!
-//! [faq]: https://github.com/rayon-rs/rayon/blob/main/FAQ.md
-
-#[macro_use]
-mod delegate;
-
-#[macro_use]
-mod private;
-
-mod split_producer;
-
-pub mod array;
-pub mod collections;
-pub mod iter;
-pub mod option;
-pub mod prelude;
-pub mod range;
-pub mod range_inclusive;
-pub mod result;
-pub mod slice;
-pub mod str;
-pub mod string;
-pub mod vec;
-
-mod math;
-mod par_either;
-
-mod compile_fail;
-
-pub use rayon_core::FnContext;
-pub use rayon_core::ThreadBuilder;
-pub use rayon_core::ThreadPool;
-pub use rayon_core::ThreadPoolBuildError;
-pub use rayon_core::ThreadPoolBuilder;
-pub use rayon_core::{broadcast, spawn_broadcast, BroadcastContext};
-pub use rayon_core::{current_num_threads, current_thread_index, max_num_threads};
-pub use rayon_core::{in_place_scope, scope, Scope};
-pub use rayon_core::{in_place_scope_fifo, scope_fifo, ScopeFifo};
-pub use rayon_core::{join, join_context};
-pub use rayon_core::{spawn, spawn_fifo};
-pub use rayon_core::{yield_local, yield_now, Yield};
-
-/// We need to transmit raw pointers across threads. It is possible to do this
-/// without any unsafe code by converting pointers to usize or to AtomicPtr<T>
-/// then back to a raw pointer for use. We prefer this approach because code
-/// that uses this type is more explicit.
-///
-/// Unsafe code is still required to dereference the pointer, so this type is
-/// not unsound on its own, although it does partly lift the unconditional
-/// !Send and !Sync on raw pointers. As always, dereference with care.
-struct SendPtr<T>(*mut T);
-
-// SAFETY: !Send for raw pointers is not for safety, just as a lint
-unsafe impl<T: Send> Send for SendPtr<T> {}
-
-// SAFETY: !Sync for raw pointers is not for safety, just as a lint
-unsafe impl<T: Send> Sync for SendPtr<T> {}
-
-impl<T> SendPtr<T> {
-    // Helper to avoid disjoint captures of `send_ptr.0`
-    fn get(self) -> *mut T {
-        self.0
-    }
-}
-
-// Implement Clone without the T: Clone bound from the derive
-impl<T> Clone for SendPtr<T> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-// Implement Copy without the T: Copy bound from the derive
-impl<T> Copy for SendPtr<T> {}

data/ext/cargo-vendor/rayon-1.10.0/src/math.rs

@@ -1,54 +0,0 @@
-use std::ops::{Bound, Range, RangeBounds};
-
-/// Divide `n` by `divisor`, and round up to the nearest integer
-/// if not evenly divisible.
-#[inline]
-pub(super) fn div_round_up(n: usize, divisor: usize) -> usize {
-    debug_assert!(divisor != 0, "Division by zero!");
-    if n == 0 {
-        0
-    } else {
-        (n - 1) / divisor + 1
-    }
-}
-
-/// Normalize arbitrary `RangeBounds` to a `Range`
-pub(super) fn simplify_range(range: impl RangeBounds<usize>, len: usize) -> Range<usize> {
-    let start = match range.start_bound() {
-        Bound::Unbounded => 0,
-        Bound::Included(&i) if i <= len => i,
-        Bound::Excluded(&i) if i < len => i + 1,
-        bound => panic!("range start {:?} should be <= length {}", bound, len),
-    };
-    let end = match range.end_bound() {
-        Bound::Unbounded => len,
-        Bound::Excluded(&i) if i <= len => i,
-        Bound::Included(&i) if i < len => i + 1,
-        bound => panic!("range end {:?} should be <= length {}", bound, len),
-    };
-    if start > end {
-        panic!(
-            "range start {:?} should be <= range end {:?}",
-            range.start_bound(),
-            range.end_bound()
-        );
-    }
-    start..end
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn check_div_round_up() {
-        assert_eq!(0, div_round_up(0, 5));
-        assert_eq!(1, div_round_up(5, 5));
-        assert_eq!(1, div_round_up(1, 5));
-        assert_eq!(2, div_round_up(3, 2));
-        assert_eq!(
-            usize::max_value() / 2 + 1,
-            div_round_up(usize::max_value(), 2)
-        );
-    }
-}

data/ext/cargo-vendor/rayon-1.10.0/src/option.rs

@@ -1,203 +0,0 @@
-//! Parallel iterator types for [options][std::option]
-//!
-//! You will rarely need to interact with this module directly unless you need
-//! to name one of the iterator types.
-//!
-//! [std::option]: https://doc.rust-lang.org/stable/std/option/
-
-use crate::iter::plumbing::*;
-use crate::iter::*;
-use std::sync::atomic::{AtomicBool, Ordering};
-
-/// A parallel iterator over the value in [`Some`] variant of an [`Option`].
-///
-/// The iterator yields one value if the [`Option`] is a [`Some`], otherwise none.
-///
-/// This `struct` is created by the [`into_par_iter`] function.
-///
-/// [`Option`]: https://doc.rust-lang.org/std/option/enum.Option.html
-/// [`Some`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some
-/// [`into_par_iter`]: ../iter/trait.IntoParallelIterator.html#tymethod.into_par_iter
-#[derive(Debug, Clone)]
-pub struct IntoIter<T: Send> {
-    opt: Option<T>,
-}
-
-impl<T: Send> IntoParallelIterator for Option<T> {
-    type Item = T;
-    type Iter = IntoIter<T>;
-
-    fn into_par_iter(self) -> Self::Iter {
-        IntoIter { opt: self }
-    }
-}
-
-impl<T: Send> ParallelIterator for IntoIter<T> {
-    type Item = T;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<Self::Item>,
-    {
-        self.drive(consumer)
-    }
-
-    fn opt_len(&self) -> Option<usize> {
-        Some(self.len())
-    }
-}
-
-impl<T: Send> IndexedParallelIterator for IntoIter<T> {
-    fn drive<C>(self, consumer: C) -> C::Result
-    where
-        C: Consumer<Self::Item>,
-    {
-        let mut folder = consumer.into_folder();
-        if let Some(item) = self.opt {
-            folder = folder.consume(item);
-        }
-        folder.complete()
-    }
-
-    fn len(&self) -> usize {
-        match self.opt {
-            Some(_) => 1,
-            None => 0,
-        }
-    }
-
-    fn with_producer<CB>(self, callback: CB) -> CB::Output
-    where
-        CB: ProducerCallback<Self::Item>,
-    {
-        callback.callback(OptionProducer { opt: self.opt })
-    }
-}
-
-/// A parallel iterator over a reference to the [`Some`] variant of an [`Option`].
-///
-/// The iterator yields one value if the [`Option`] is a [`Some`], otherwise none.
-///
-/// This `struct` is created by the [`par_iter`] function.
-///
-/// [`Option`]: https://doc.rust-lang.org/std/option/enum.Option.html
-/// [`Some`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some
-/// [`par_iter`]: ../iter/trait.IntoParallelRefIterator.html#tymethod.par_iter
-#[derive(Debug)]
-pub struct Iter<'a, T: Sync> {
-    inner: IntoIter<&'a T>,
-}
-
-impl<'a, T: Sync> Clone for Iter<'a, T> {
-    fn clone(&self) -> Self {
-        Iter {
-            inner: self.inner.clone(),
-        }
-    }
-}
-
-impl<'a, T: Sync> IntoParallelIterator for &'a Option<T> {
-    type Item = &'a T;
-    type Iter = Iter<'a, T>;
-
-    fn into_par_iter(self) -> Self::Iter {
-        Iter {
-            inner: self.as_ref().into_par_iter(),
-        }
-    }
-}
-
-delegate_indexed_iterator! {
-    Iter<'a, T> => &'a T,
-    impl<'a, T: Sync + 'a>
-}
-
-/// A parallel iterator over a mutable reference to the [`Some`] variant of an [`Option`].
-///
-/// The iterator yields one value if the [`Option`] is a [`Some`], otherwise none.
-///
-/// This `struct` is created by the [`par_iter_mut`] function.
-///
-/// [`Option`]: https://doc.rust-lang.org/std/option/enum.Option.html
-/// [`Some`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some
-/// [`par_iter_mut`]: ../iter/trait.IntoParallelRefMutIterator.html#tymethod.par_iter_mut
-#[derive(Debug)]
-pub struct IterMut<'a, T: Send> {
-    inner: IntoIter<&'a mut T>,
-}
-
-impl<'a, T: Send> IntoParallelIterator for &'a mut Option<T> {
-    type Item = &'a mut T;
-    type Iter = IterMut<'a, T>;
-
-    fn into_par_iter(self) -> Self::Iter {
-        IterMut {
-            inner: self.as_mut().into_par_iter(),
-        }
-    }
-}
-
-delegate_indexed_iterator! {
-    IterMut<'a, T> => &'a mut T,
-    impl<'a, T: Send + 'a>
-}
-
-/// Private producer for an option
-struct OptionProducer<T: Send> {
-    opt: Option<T>,
-}
-
-impl<T: Send> Producer for OptionProducer<T> {
-    type Item = T;
-    type IntoIter = std::option::IntoIter<T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.opt.into_iter()
-    }
-
-    fn split_at(self, index: usize) -> (Self, Self) {
-        debug_assert!(index <= 1);
-        let none = OptionProducer { opt: None };
-        if index == 0 {
-            (none, self)
-        } else {
-            (self, none)
-        }
-    }
-}
-
-/// Collect an arbitrary `Option`-wrapped collection.
-///
-/// If any item is `None`, then all previous items collected are discarded,
-/// and it returns only `None`.
-impl<C, T> FromParallelIterator<Option<T>> for Option<C>
-where
-    C: FromParallelIterator<T>,
-    T: Send,
-{
-    fn from_par_iter<I>(par_iter: I) -> Self
-    where
-        I: IntoParallelIterator<Item = Option<T>>,
-    {
-        fn check<T>(found_none: &AtomicBool) -> impl Fn(&Option<T>) + '_ {
-            move |item| {
-                if item.is_none() {
-                    found_none.store(true, Ordering::Relaxed);
-                }
-            }
-        }
-
-        let found_none = AtomicBool::new(false);
-        let collection = par_iter
-            .into_par_iter()
-            .inspect(check(&found_none))
-            .while_some()
-            .collect();
-
-        if found_none.load(Ordering::Relaxed) {
-            None
-        } else {
-            Some(collection)
-        }
-    }
-}