Move stuff over to using streams instead of iterators: much nicer!

1 files changed, 37 insertions, 54 deletions

diff --git a/src/main/java/au/id/zancanaro/javacheck/Generators.java b/src/main/java/au/id/zancanaro/javacheck/Generators.java
index 9730bac..619fe2d 100644
--- a/src/main/java/au/id/zancanaro/javacheck/Generators.java
+++ b/src/main/java/au/id/zancanaro/javacheck/Generators.java
@@ -1,7 +1,10 @@
 package au.id.zancanaro.javacheck;
 
 import java.util.*;
+import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 @SuppressWarnings({"unused", "WeakerAccess"})
 public final class Generators {
@@ -29,7 +32,7 @@ public final class Generators {
      * removed
      */
     public static <T> Generator<T> noShrink(Generator<T> gen) {
-        return gen.withShrinkStrategy(value -> Iterators.emptyIterator());
+        return gen.withShrinkStrategy(value -> Stream.empty());
     }
 
     @SafeVarargs
@@ -52,23 +55,7 @@ public final class Generators {
     }
 
     private static ShrinkStrategy<Boolean> boolShrinkStrategy() {
-        return value -> new Iterator<Boolean>() {
-            boolean hasMore = value;
-
-            @Override
-            public boolean hasNext() {
-                return hasMore;
-            }
-
-            @Override
-            public Boolean next() {
-                if (hasMore) {
-                    return (hasMore = false);
-                } else {
-                    throw new NoSuchElementException("Boolean shrink tree exhausted");
-                }
-            }
-        };
+        return value -> (value ? Stream.of(false) : Stream.empty());
     }
 
     public static Generator<Long> longInteger(long lower, long upper) {
@@ -85,21 +72,19 @@ public final class Generators {
     }
 
     private static ShrinkStrategy<Long> longShrinkStrategy(final long bound) {
-        return value -> new Iterator<Long>() {
+        return value -> StreamSupport.stream(new Spliterators.AbstractSpliterator<Long>(Long.MAX_VALUE, Spliterator.ORDERED) {
             long curr = value - bound;
-
             @Override
-            public boolean hasNext() {
-                return curr != 0;
-            }
-
-            @Override
-            public Long next() {
-                long prevCurr = curr;
-                curr = curr / 2;
-                return value - prevCurr;
+            public boolean tryAdvance(Consumer<? super Long> action) {
+                if (curr == 0) {
+                    return false;
+                } else {
+                    action.accept(value - curr);
+                    curr /= 2;
+                    return true;
+                }
             }
-        };
+        }, false);
     }
 
     public static Generator<Integer> integer(int lower, int upper) {
@@ -119,22 +104,21 @@ public final class Generators {
         return sized(size -> integer(0, size));
     }
 
-    public static ShrinkStrategy<Integer> intShrinkStrategy(int bound) {
-        return value -> new Iterator<Integer>() {
+    private static ShrinkStrategy<Integer> intShrinkStrategy(final int bound) {
+        return value -> StreamSupport.stream(new Spliterators.AbstractSpliterator<Integer>(Long.MAX_VALUE, Spliterator.ORDERED) {
             int curr = value - bound;
 
             @Override
-            public boolean hasNext() {
-                return curr != 0;
-            }
-
-            @Override
-            public Integer next() {
-                int prevCurr = curr;
-                curr = curr / 2;
-                return value - prevCurr;
+            public boolean tryAdvance(Consumer<? super Integer> action) {
+                if (curr == 0) {
+                    return false;
+                } else {
+                    action.accept(value - curr);
+                    curr /= 2;
+                    return true;
+                }
             }
-        };
+        }, false);
     }
 
     public static Generator<Double> doublePrecision(double lower, double upper) {
@@ -150,22 +134,21 @@ public final class Generators {
         return sized(size -> doublePrecision(-size, size));
     }
 
-    public static ShrinkStrategy<Double> doubleShrinkStrategy(double bound, double epsilon) {
-        return value -> new Iterator<Double>() {
+    private static ShrinkStrategy<Double> doubleShrinkStrategy(final double bound, double epsilon) {
+        return value -> StreamSupport.stream(new Spliterators.AbstractSpliterator<Double>(Long.MAX_VALUE, Spliterator.ORDERED) {
             double curr = value - bound;
 
             @Override
-            public boolean hasNext() {
-                return Math.abs(curr) > epsilon;
-            }
-
-            @Override
-            public Double next() {
-                double prevCurr = curr;
-                curr = curr / 2;
-                return value - prevCurr;
+            public boolean tryAdvance(Consumer<? super Double> action) {
+                if (Math.abs(curr) < epsilon) {
+                    return false;
+                } else {
+                    action.accept(value - curr);
+                    curr /= 2;
+                    return true;
+                }
             }
-        };
+        }, false);
     }
 
     public static <T> Generator<List<T>> listOf(Generator<T> gen, int minElements, int maxElements) {