New upstream version 0.52.0

[cargo.git] / vendor / sized-chunks / src / arbitrary.rs

diff --git a/vendor/sized-chunks/src/arbitrary.rs b/vendor/sized-chunks/src/arbitrary.rs
index fc49984ff44fb449111b30551b82bc52c40698f8..718937e26ba1fa423cbb9db8b59111b4350d2a8b 100644 (file)
--- a/vendor/sized-chunks/src/arbitrary.rs
+++ b/vendor/sized-chunks/src/arbitrary.rs
@@ -3,7 +3,6 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 use bitmaps::Bits;
-use core::iter;
 
 use ::arbitrary::{size_hint, Arbitrary, Result, Unstructured};
 
@@ -12,49 +11,16 @@ use crate::{types::ChunkLength, Chunk, InlineArray, SparseChunk};
 #[cfg(feature = "ringbuffer")]
 use crate::RingBuffer;
 
-fn empty<T: 'static>() -> Box<dyn Iterator<Item = T>> {
-    Box::new(iter::empty())
-}
-
-fn shrink_collection<T: Clone, A: Arbitrary>(
-    entries: impl Iterator<Item = T>,
-    f: impl Fn(&T) -> Box<dyn Iterator<Item = A>>,
-) -> Box<dyn Iterator<Item = Vec<A>>> {
-    let entries: Vec<_> = entries.collect();
-    if entries.is_empty() {
-        return empty();
-    }
-
-    let mut shrinkers: Vec<Vec<_>> = vec![];
-    let mut i = entries.len();
-    loop {
-        shrinkers.push(entries.iter().take(i).map(&f).collect());
-        i /= 2;
-        if i == 0 {
-            break;
-        }
-    }
-    Box::new(iter::once(Vec::new()).chain(iter::from_fn(move || loop {
-        let mut shrinker = shrinkers.pop()?;
-        let x: Option<Vec<A>> = shrinker.iter_mut().map(|s| s.next()).collect();
-        if x.is_none() {
-            continue;
-        }
-        shrinkers.push(shrinker);
-        return x;
-    })))
-}
-
-impl<A, N> Arbitrary for Chunk<A, N>
+impl<'a, A, N> Arbitrary<'a> for Chunk<A, N>
 where
-    A: Arbitrary,
+    A: Arbitrary<'a>,
     N: ChunkLength<A> + 'static,
 {
-    fn arbitrary(u: &mut Unstructured<'_>) -> Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
         u.arbitrary_iter()?.take(Self::CAPACITY).collect()
     }
 
-    fn arbitrary_take_rest(u: Unstructured<'_>) -> Result<Self> {
+    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
         u.arbitrary_take_rest_iter()?.take(Self::CAPACITY).collect()
     }
 
@@ -64,24 +30,19 @@ where
             (0, upper.map(|upper| upper * Self::CAPACITY))
         })
     }
-
-    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
-        let collections = shrink_collection(self.iter(), |x| x.shrink());
-        Box::new(collections.map(|entries| entries.into_iter().collect()))
-    }
 }
 
 #[cfg(feature = "ringbuffer")]
-impl<A, N> Arbitrary for RingBuffer<A, N>
+impl<'a, A, N> Arbitrary<'a> for RingBuffer<A, N>
 where
-    A: Arbitrary,
+    A: Arbitrary<'a>,
     N: ChunkLength<A> + 'static,
 {
-    fn arbitrary(u: &mut Unstructured<'_>) -> Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
         u.arbitrary_iter()?.take(Self::CAPACITY).collect()
     }
 
-    fn arbitrary_take_rest(u: Unstructured<'_>) -> Result<Self> {
+    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
         u.arbitrary_take_rest_iter()?.take(Self::CAPACITY).collect()
     }
 
@@ -91,24 +52,19 @@ where
             (0, upper.map(|upper| upper * Self::CAPACITY))
         })
     }
-
-    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
-        let collections = shrink_collection(self.iter(), |x| x.shrink());
-        Box::new(collections.map(|entries| entries.into_iter().collect()))
-    }
 }
 
-impl<A, N> Arbitrary for SparseChunk<A, N>
+impl<'a, A, N> Arbitrary<'a> for SparseChunk<A, N>
 where
     A: Clone,
-    Option<A>: Arbitrary,
+    Option<A>: Arbitrary<'a>,
     N: ChunkLength<A> + Bits + 'static,
 {
-    fn arbitrary(u: &mut Unstructured<'_>) -> Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
         u.arbitrary_iter()?.take(Self::CAPACITY).collect()
     }
 
-    fn arbitrary_take_rest(u: Unstructured<'_>) -> Result<Self> {
+    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
         u.arbitrary_take_rest_iter()?.take(Self::CAPACITY).collect()
     }
 
@@ -118,23 +74,18 @@ where
             (0, upper.map(|upper| upper * Self::CAPACITY))
         })
     }
-
-    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
-        let collections = shrink_collection(self.clone().option_drain(), |x| x.shrink());
-        Box::new(collections.map(|entries| entries.into_iter().collect()))
-    }
 }
 
-impl<A, T> Arbitrary for InlineArray<A, T>
+impl<'a, A, T> Arbitrary<'a> for InlineArray<A, T>
 where
-    A: Arbitrary,
+    A: Arbitrary<'a>,
     T: 'static,
 {
-    fn arbitrary(u: &mut Unstructured<'_>) -> Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
         u.arbitrary_iter()?.take(Self::CAPACITY).collect()
     }
 
-    fn arbitrary_take_rest(u: Unstructured<'_>) -> Result<Self> {
+    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
         u.arbitrary_take_rest_iter()?.take(Self::CAPACITY).collect()
     }
 
@@ -144,9 +95,4 @@ where
             (0, upper.map(|upper| upper * Self::CAPACITY))
         })
     }
-
-    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
-        let collections = shrink_collection(self.iter(), |x| x.shrink());
-        Box::new(collections.map(|entries| entries.into_iter().collect()))
-    }
 }