Hide non-standard APIs from java.util.stream
Change-Id: Idcd5c9390ad0305d075a6b1ea070e1f9aa304797
Review-Link: https://gwt-review.googlesource.com/#/c/17540/
diff --git a/user/super/com/google/gwt/emul/java/util/stream/Collector.java b/user/super/com/google/gwt/emul/java/util/stream/Collector.java
index ce41e92..c3907ef 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/Collector.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/Collector.java
@@ -13,7 +13,6 @@
* License for the specific language governing permissions and limitations under
* the License.
*/
-
package java.util.stream;
import static javaemul.internal.InternalPreconditions.checkNotNull;
@@ -90,73 +89,4 @@
BinaryOperator<A> combiner();
Function<A,R> finisher();
-
- /**
- * Simple internal implementation of a collector, holding each of the functions in a field.
- */
- final class CollectorImpl<T, A, R> implements Collector<T, A, R> {
- private final Supplier<A> supplier;
- private final BiConsumer<A, T> accumulator;
- private final Set<Characteristics> characteristics;
- private final BinaryOperator<A> combiner;
- private final Function<A, R> finisher;
-
- public CollectorImpl(
- Supplier<A> supplier,
- BiConsumer<A, T> accumulator,
- BinaryOperator<A> combiner,
- Function<A, R> finisher,
- Characteristics... characteristics) {
- this.supplier = supplier;
- this.accumulator = accumulator;
- if (characteristics.length == 0) {
- this.characteristics = Collections.emptySet();
- } else if (characteristics.length == 1) {
- this.characteristics = Collections.singleton(characteristics[0]);
- } else {
- this.characteristics =
- Collections.unmodifiableSet(EnumSet.of(characteristics[0], characteristics));
- }
- this.combiner = combiner;
- this.finisher = finisher;
- }
-
- public CollectorImpl(
- Supplier<A> supplier,
- BiConsumer<A, T> accumulator,
- BinaryOperator<A> combiner,
- Function<A, R> finisher,
- Set<Characteristics> characteristics) {
- this.supplier = supplier;
- this.accumulator = accumulator;
- this.combiner = combiner;
- this.finisher = finisher;
- this.characteristics = characteristics;
- }
-
- @Override
- public Supplier<A> supplier() {
- return supplier;
- }
-
- @Override
- public BiConsumer<A, T> accumulator() {
- return accumulator;
- }
-
- @Override
- public BinaryOperator<A> combiner() {
- return combiner;
- }
-
- @Override
- public Function<A, R> finisher() {
- return finisher;
- }
-
- @Override
- public Set<Characteristics> characteristics() {
- return characteristics;
- }
- }
}
\ No newline at end of file
diff --git a/user/super/com/google/gwt/emul/java/util/stream/CollectorImpl.java b/user/super/com/google/gwt/emul/java/util/stream/CollectorImpl.java
new file mode 100644
index 0000000..9202a28
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/stream/CollectorImpl.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package java.util.stream;
+
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/**
+ * Simple internal implementation of a collector, holding each of the functions in a field.
+ */
+final class CollectorImpl<T, A, R> implements Collector<T, A, R> {
+ private final Supplier<A> supplier;
+ private final BiConsumer<A, T> accumulator;
+ private final Set<Characteristics> characteristics;
+ private final BinaryOperator<A> combiner;
+ private final Function<A, R> finisher;
+
+ public CollectorImpl(
+ Supplier<A> supplier,
+ BiConsumer<A, T> accumulator,
+ BinaryOperator<A> combiner,
+ Function<A, R> finisher,
+ Characteristics... characteristics) {
+ this.supplier = supplier;
+ this.accumulator = accumulator;
+ if (characteristics.length == 0) {
+ this.characteristics = Collections.emptySet();
+ } else if (characteristics.length == 1) {
+ this.characteristics = Collections.singleton(characteristics[0]);
+ } else {
+ this.characteristics =
+ Collections.unmodifiableSet(EnumSet.of(characteristics[0], characteristics));
+ }
+ this.combiner = combiner;
+ this.finisher = finisher;
+ }
+
+ public CollectorImpl(
+ Supplier<A> supplier,
+ BiConsumer<A, T> accumulator,
+ BinaryOperator<A> combiner,
+ Function<A, R> finisher,
+ Set<Characteristics> characteristics) {
+ this.supplier = supplier;
+ this.accumulator = accumulator;
+ this.combiner = combiner;
+ this.finisher = finisher;
+ this.characteristics = characteristics;
+ }
+
+ @Override
+ public Supplier<A> supplier() {
+ return supplier;
+ }
+
+ @Override
+ public BiConsumer<A, T> accumulator() {
+ return accumulator;
+ }
+
+ @Override
+ public BinaryOperator<A> combiner() {
+ return combiner;
+ }
+
+ @Override
+ public Function<A, R> finisher() {
+ return finisher;
+ }
+
+ @Override
+ public Set<Characteristics> characteristics() {
+ return characteristics;
+ }
+}
diff --git a/user/super/com/google/gwt/emul/java/util/stream/Collectors.java b/user/super/com/google/gwt/emul/java/util/stream/Collectors.java
index c19dfef..65edfa5 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/Collectors.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/Collectors.java
@@ -64,7 +64,7 @@
public static <T, A, R, RR> Collector<T, A, RR> collectingAndThen(
Collector<T, A, R> downstream, Function<R, RR> finisher) {
- return new Collector.CollectorImpl<>(
+ return new CollectorImpl<>(
downstream.supplier(),
downstream.accumulator(),
downstream.combiner(),
@@ -163,15 +163,15 @@
public static <T, U, A, R> Collector<T, ?, R> mapping(
final Function<? super T, ? extends U> mapper, final Collector<? super U, A, R> downstream) {
- return new Collector.CollectorImpl<>(
+ return new CollectorImpl<>(
downstream.supplier(),
- (BiConsumer<A, T>) (A a, T t) -> {
- downstream.accumulator().accept(a, mapper.apply(t));
- },
+ (BiConsumer<A, T>)
+ (A a, T t) -> {
+ downstream.accumulator().accept(a, mapper.apply(t));
+ },
downstream.combiner(),
downstream.finisher(),
- downstream.characteristics()
- );
+ downstream.characteristics());
}
public static <T> Collector<T,?,Optional<T>> maxBy(Comparator<? super T> comparator) {
diff --git a/user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java b/user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java
index bfe782c..75b0474 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java
@@ -13,22 +13,17 @@
* License for the specific language governing permissions and limitations under
* the License.
*/
-
package java.util.stream;
-import static javaemul.internal.InternalPreconditions.checkNotNull;
import static javaemul.internal.InternalPreconditions.checkState;
import java.util.Arrays;
-import java.util.Comparator;
import java.util.DoubleSummaryStatistics;
-import java.util.HashSet;
import java.util.OptionalDouble;
import java.util.PrimitiveIterator;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.BiConsumer;
-import java.util.function.Consumer;
import java.util.function.DoubleBinaryOperator;
import java.util.function.DoubleConsumer;
import java.util.function.DoubleFunction;
@@ -37,8 +32,6 @@
import java.util.function.DoubleToIntFunction;
import java.util.function.DoubleToLongFunction;
import java.util.function.DoubleUnaryOperator;
-import java.util.function.IntConsumer;
-import java.util.function.LongConsumer;
import java.util.function.ObjDoubleConsumer;
import java.util.function.Supplier;
@@ -49,18 +42,23 @@
public interface DoubleStream extends BaseStream<Double, DoubleStream> {
/**
- * Value holder for various stream operations.
+ * See <a
+ * href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/DoubleStream.Builder.html">the
+ * official Java API doc</a> for details.
*/
- static final class ValueConsumer implements DoubleConsumer {
- double value;
-
+ interface Builder extends DoubleConsumer {
@Override
- public void accept(double value) {
- this.value = value;
+ void accept(double t);
+
+ default DoubleStream.Builder add(double t) {
+ accept(t);
+ return this;
}
+
+ DoubleStream build();
}
- static DoubleStream.Builder builder() {
+ static Builder builder() {
return new Builder() {
private double[] items = new double[0];
@@ -124,7 +122,7 @@
}
};
- DoubleStream result = new DoubleStreamSource(null, spliterator);
+ DoubleStream result = new DoubleStreamImpl(null, spliterator);
result.onClose(a::close);
result.onClose(b::close);
@@ -133,7 +131,7 @@
}
static DoubleStream empty() {
- return new EmptyDoubleStreamSource(null);
+ return new DoubleStreamImpl.Empty(null);
}
static DoubleStream generate(DoubleSupplier s) {
@@ -176,23 +174,6 @@
return of(new double[] {t});
}
- /**
- * See
- * <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/DoubleStream.Builder.html">
- * the official Java API doc</a> for details.
- */
- public interface Builder extends DoubleConsumer {
- @Override
- void accept(double t);
-
- default DoubleStream.Builder add(double t) {
- accept(t);
- return this;
- }
-
- DoubleStream build();
- }
-
boolean allMatch(DoublePredicate predicate);
boolean anyMatch(DoublePredicate predicate);
@@ -262,763 +243,4 @@
DoubleSummaryStatistics summaryStatistics();
double[] toArray();
-
- /**
- * Represents an empty stream, doing nothing for all methods.
- */
- static class EmptyDoubleStreamSource extends TerminatableStream<EmptyDoubleStreamSource>
- implements DoubleStream {
- public EmptyDoubleStreamSource(TerminatableStream<?> previous) {
- super(previous);
- }
-
- @Override
- public DoubleStream filter(DoublePredicate predicate) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public DoubleStream map(DoubleUnaryOperator mapper) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper) {
- throwIfTerminated();
- return new Stream.EmptyStreamSource<U>(this);
- }
-
- @Override
- public IntStream mapToInt(DoubleToIntFunction mapper) {
- throwIfTerminated();
- return new IntStream.EmptyIntStreamSource(this);
- }
-
- @Override
- public LongStream mapToLong(DoubleToLongFunction mapper) {
- throwIfTerminated();
- return new LongStream.EmptyLongStreamSource(this);
- }
-
- @Override
- public DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public DoubleStream distinct() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public DoubleStream sorted() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public DoubleStream peek(DoubleConsumer action) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public DoubleStream limit(long maxSize) {
- throwIfTerminated();
- checkState(maxSize >= 0, "maxSize may not be negative");
- return this;
- }
-
- @Override
- public DoubleStream skip(long n) {
- throwIfTerminated();
- checkState(n >= 0, "n may not be negative");
- return this;
- }
-
- @Override
- public void forEach(DoubleConsumer action) {
- terminate();
- // do nothing
- }
-
- @Override
- public void forEachOrdered(DoubleConsumer action) {
- terminate();
- // do nothing
- }
-
- @Override
- public double[] toArray() {
- terminate();
- return new double[0];
- }
-
- @Override
- public double reduce(double identity, DoubleBinaryOperator op) {
- terminate();
- return identity;
- }
-
- @Override
- public OptionalDouble reduce(DoubleBinaryOperator op) {
- terminate();
- return OptionalDouble.empty();
- }
-
- @Override
- public <R> R collect(
- Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> combiner) {
- terminate();
- return supplier.get();
- }
-
- @Override
- public double sum() {
- terminate();
- return 0;
- }
-
- @Override
- public OptionalDouble min() {
- terminate();
- return OptionalDouble.empty();
- }
-
- @Override
- public OptionalDouble max() {
- terminate();
- return OptionalDouble.empty();
- }
-
- @Override
- public long count() {
- terminate();
- return 0;
- }
-
- @Override
- public OptionalDouble average() {
- terminate();
- return OptionalDouble.empty();
- }
-
- @Override
- public DoubleSummaryStatistics summaryStatistics() {
- terminate();
- return new DoubleSummaryStatistics();
- }
-
- @Override
- public boolean anyMatch(DoublePredicate predicate) {
- terminate();
- return false;
- }
-
- @Override
- public boolean allMatch(DoublePredicate predicate) {
- terminate();
- return true;
- }
-
- @Override
- public boolean noneMatch(DoublePredicate predicate) {
- terminate();
- return true;
- }
-
- @Override
- public OptionalDouble findFirst() {
- terminate();
- return OptionalDouble.empty();
- }
-
- @Override
- public OptionalDouble findAny() {
- terminate();
- return OptionalDouble.empty();
- }
-
- @Override
- public Stream<Double> boxed() {
- throwIfTerminated();
- return new Stream.EmptyStreamSource<Double>(this);
- }
-
- @Override
- public DoubleStream sequential() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public DoubleStream parallel() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public PrimitiveIterator.OfDouble iterator() {
- return Spliterators.iterator(spliterator());
- }
-
- @Override
- public Spliterator.OfDouble spliterator() {
- terminate();
- return Spliterators.emptyDoubleSpliterator();
- }
-
- @Override
- public boolean isParallel() {
- throwIfTerminated();
- return false;
- }
-
- @Override
- public DoubleStream unordered() {
- throwIfTerminated();
- return this;
- }
- }
-
- /**
- * Double to Int map spliterator.
- */
- static final class MapToIntSpliterator extends Spliterators.AbstractIntSpliterator {
- private final DoubleToIntFunction map;
- private final Spliterator.OfDouble original;
-
- public MapToIntSpliterator(DoubleToIntFunction map, Spliterator.OfDouble original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final IntConsumer action) {
- return original.tryAdvance((double u) -> action.accept(map.applyAsInt(u)));
- }
- }
-
- /**
- * Double to Object map spliterator.
- * @param <T> the type of Object in the spliterator
- */
- static final class MapToObjSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
- private final DoubleFunction<? extends T> map;
- private final Spliterator.OfDouble original;
-
- public MapToObjSpliterator(DoubleFunction<? extends T> map, Spliterator.OfDouble original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final Consumer<? super T> action) {
- return original.tryAdvance((double u) -> action.accept(map.apply(u)));
- }
- }
-
- /**
- * Double to Long map spliterator.
- */
- static final class MapToLongSpliterator extends Spliterators.AbstractLongSpliterator {
- private final DoubleToLongFunction map;
- private final Spliterator.OfDouble original;
-
- public MapToLongSpliterator(DoubleToLongFunction map, Spliterator.OfDouble original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final LongConsumer action) {
- return original.tryAdvance((double u) -> action.accept(map.applyAsLong(u)));
- }
- }
-
- /**
- * Double to Double map spliterator.
- */
- static final class MapToDoubleSpliterator extends Spliterators.AbstractDoubleSpliterator {
- private final DoubleUnaryOperator map;
- private final Spliterator.OfDouble original;
-
- public MapToDoubleSpliterator(DoubleUnaryOperator map, Spliterator.OfDouble original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final DoubleConsumer action) {
- return original.tryAdvance((double u) -> action.accept(map.applyAsDouble(u)));
- }
- }
-
- /**
- * Double filter spliterator.
- */
- static final class FilterSpliterator extends Spliterators.AbstractDoubleSpliterator {
- private final DoublePredicate filter;
- private final Spliterator.OfDouble original;
-
- private boolean found;
-
- public FilterSpliterator(DoublePredicate filter, Spliterator.OfDouble original) {
- super(original.estimateSize(), original.characteristics() & ~Spliterator.SIZED);
- checkNotNull(filter);
- this.filter = filter;
- this.original = original;
- }
-
- @Override
- public Comparator<? super Double> getComparator() {
- return original.getComparator();
- }
-
- @Override
- public boolean tryAdvance(final DoubleConsumer action) {
- found = false;
- while (!found
- && original.tryAdvance(
- (double item) -> {
- if (filter.test(item)) {
- found = true;
- action.accept(item);
- }
- })) {
- // do nothing, work is done in tryAdvance
- }
-
- return found;
- }
- }
-
- /**
- * Double skip spliterator.
- */
- static final class SkipSpliterator extends Spliterators.AbstractDoubleSpliterator {
- private long skip;
- private final Spliterator.OfDouble original;
-
- public SkipSpliterator(long skip, Spliterator.OfDouble original) {
- super(
- original.hasCharacteristics(Spliterator.SIZED)
- ? Math.max(0, original.estimateSize() - skip)
- : Long.MAX_VALUE,
- original.characteristics());
- this.skip = skip;
- this.original = original;
- }
-
- @Override
- public Comparator<? super Double> getComparator() {
- return original.getComparator();
- }
-
- @Override
- public boolean tryAdvance(DoubleConsumer action) {
- while (skip > 0) {
- if (!original.tryAdvance((double ignore) -> { })) {
- return false;
- }
- skip--;
- }
- return original.tryAdvance(action);
- }
- }
-
- /**
- * Double limit spliterator.
- */
- static final class LimitSpliterator extends Spliterators.AbstractDoubleSpliterator {
- private final long limit;
- private final Spliterator.OfDouble original;
- private int position = 0;
-
- public LimitSpliterator(long limit, Spliterator.OfDouble original) {
- super(
- original.hasCharacteristics(Spliterator.SIZED)
- ? Math.min(original.estimateSize(), limit)
- : Long.MAX_VALUE,
- original.characteristics());
- this.limit = limit;
- this.original = original;
- }
-
- @Override
- public Comparator<? super Double> getComparator() {
- return original.getComparator();
- }
-
- @Override
- public boolean tryAdvance(DoubleConsumer action) {
- if (position >= limit) {
- return false;
- }
-
- boolean result = original.tryAdvance(action);
- position++;
- return result;
- }
- }
-
- /**
- * Main implementation of DoubleStream, wrapping a single spliterator, and an optional parent
- * stream.
- */
- static class DoubleStreamSource extends TerminatableStream<DoubleStreamSource>
- implements DoubleStream {
- private final Spliterator.OfDouble spliterator;
-
- public DoubleStreamSource(TerminatableStream<?> previous, Spliterator.OfDouble spliterator) {
- super(previous);
- this.spliterator = spliterator;
- }
-
- // terminals
-
- @Override
- public void forEach(DoubleConsumer action) {
- forEachOrdered(action);
- }
-
- @Override
- public void forEachOrdered(DoubleConsumer action) {
- terminate();
- spliterator.forEachRemaining(action);
- }
-
- @Override
- public double[] toArray() {
- terminate();
- double[] entries = new double[0];
- // this is legal in js, since the array will be backed by a JS array
- spliterator.forEachRemaining((double value) -> entries[entries.length] = value);
-
- return entries;
- }
-
- @Override
- public double reduce(double identity, DoubleBinaryOperator op) {
- terminate();
- ValueConsumer holder = new ValueConsumer();
- holder.value = identity;
- spliterator.forEachRemaining(
- (double value) -> {
- holder.accept(op.applyAsDouble(holder.value, value));
- });
- return holder.value;
- }
-
- @Override
- public OptionalDouble reduce(DoubleBinaryOperator op) {
- ValueConsumer holder = new ValueConsumer();
- if (spliterator.tryAdvance(holder)) {
- return OptionalDouble.of(reduce(holder.value, op));
- }
- terminate();
- return OptionalDouble.empty();
- }
-
- @Override
- public <R> R collect(
- Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> combiner) {
- terminate();
- final R acc = supplier.get();
- spliterator.forEachRemaining((double value) -> accumulator.accept(acc, value));
- return acc;
- }
-
- @Override
- public double sum() {
- return summaryStatistics().getSum();
- }
-
- @Override
- public OptionalDouble min() {
- DoubleSummaryStatistics stats = summaryStatistics();
- if (stats.getCount() == 0) {
- return OptionalDouble.empty();
- }
- return OptionalDouble.of(stats.getMin());
- }
-
- @Override
- public OptionalDouble max() {
- DoubleSummaryStatistics stats = summaryStatistics();
- if (stats.getCount() == 0) {
- return OptionalDouble.empty();
- }
- return OptionalDouble.of(stats.getMax());
- }
-
- @Override
- public long count() {
- terminate();
- long count = 0;
- while (spliterator.tryAdvance((double value) -> { })) {
- count++;
- }
- return count;
- }
-
- @Override
- public OptionalDouble average() {
- DoubleSummaryStatistics stats = summaryStatistics();
- if (stats.getCount() == 0) {
- return OptionalDouble.empty();
- }
- return OptionalDouble.of(stats.getAverage());
- }
-
- @Override
- public DoubleSummaryStatistics summaryStatistics() {
- return collect(
- DoubleSummaryStatistics::new,
- // TODO switch to a lambda reference once #9340 is fixed
- (doubleSummaryStatistics, value) -> doubleSummaryStatistics.accept(value),
- DoubleSummaryStatistics::combine);
- }
-
- @Override
- public boolean anyMatch(DoublePredicate predicate) {
- return filter(predicate).findFirst().isPresent();
- }
-
- @Override
- public boolean allMatch(DoublePredicate predicate) {
- return !anyMatch(predicate.negate());
- }
-
- @Override
- public boolean noneMatch(DoublePredicate predicate) {
- return !anyMatch(predicate);
- }
-
- @Override
- public OptionalDouble findFirst() {
- terminate();
- ValueConsumer holder = new ValueConsumer();
- if (spliterator.tryAdvance(holder)) {
- return OptionalDouble.of(holder.value);
- }
- return OptionalDouble.empty();
- }
-
- @Override
- public OptionalDouble findAny() {
- return findFirst();
- }
-
- @Override
- public PrimitiveIterator.OfDouble iterator() {
- return Spliterators.iterator(spliterator());
- }
-
- @Override
- public Spliterator.OfDouble spliterator() {
- terminate();
- return spliterator;
- }
-
- // end terminals
-
- // intermediates
-
- @Override
- public DoubleStream filter(DoublePredicate predicate) {
- throwIfTerminated();
- return new DoubleStreamSource(this, new FilterSpliterator(predicate, spliterator));
- }
-
- @Override
- public DoubleStream map(DoubleUnaryOperator mapper) {
- throwIfTerminated();
- return new DoubleStreamSource(this, new MapToDoubleSpliterator(mapper, spliterator));
- }
-
- @Override
- public <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper) {
- throwIfTerminated();
- return new Stream.StreamSource<U>(this, new MapToObjSpliterator<U>(mapper, spliterator));
- }
-
- @Override
- public IntStream mapToInt(DoubleToIntFunction mapper) {
- throwIfTerminated();
- return new IntStream.IntStreamSource(this, new MapToIntSpliterator(mapper, spliterator));
- }
-
- @Override
- public LongStream mapToLong(DoubleToLongFunction mapper) {
- throwIfTerminated();
- return new LongStream.LongStreamSource(this, new MapToLongSpliterator(mapper, spliterator));
- }
-
- @Override
- public DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper) {
- throwIfTerminated();
- final Spliterator<? extends DoubleStream> spliteratorOfStreams =
- new MapToObjSpliterator<DoubleStream>(mapper, spliterator);
-
- Spliterator.OfDouble flatMapSpliterator =
- new Spliterators.AbstractDoubleSpliterator(Long.MAX_VALUE, 0) {
- DoubleStream nextStream;
- Spliterator.OfDouble next;
-
- @Override
- public boolean tryAdvance(DoubleConsumer action) {
- // look for a new spliterator
- while (advanceToNextSpliterator()) {
- // if we have one, try to read and use it
- if (next.tryAdvance(action)) {
- return true;
- } else {
- nextStream.close();
- nextStream = null;
- // failed, null it out so we can find another
- next = null;
- }
- }
- return false;
- }
-
- private boolean advanceToNextSpliterator() {
- while (next == null) {
- if (!spliteratorOfStreams.tryAdvance(
- n -> {
- if (n != null) {
- nextStream = n;
- next = n.spliterator();
- }
- })) {
- return false;
- }
- }
- return true;
- }
- };
-
- return new DoubleStreamSource(this, flatMapSpliterator);
- }
-
- @Override
- public DoubleStream distinct() {
- throwIfTerminated();
- HashSet<Double> seen = new HashSet<>();
- return filter(seen::add);
- }
-
- @Override
- public DoubleStream sorted() {
- throwIfTerminated();
-
- Spliterator.OfDouble sortingSpliterator =
- new Spliterators.AbstractDoubleSpliterator(
- spliterator.estimateSize(), spliterator.characteristics() | Spliterator.SORTED) {
- Spliterator.OfDouble ordered = null;
-
- @Override
- public Comparator<? super Double> getComparator() {
- return null;
- }
-
- @Override
- public boolean tryAdvance(DoubleConsumer action) {
- if (ordered == null) {
- double[] list = new double[0];
- spliterator.forEachRemaining((double item) -> list[list.length] = item);
- Arrays.sort(list);
- ordered = Spliterators.spliterator(list, characteristics());
- }
- return ordered.tryAdvance(action);
- }
- };
-
- return new DoubleStreamSource(this, sortingSpliterator);
- }
-
- @Override
- public DoubleStream peek(DoubleConsumer action) {
- checkNotNull(action);
- throwIfTerminated();
-
- Spliterator.OfDouble peekSpliterator =
- new Spliterators.AbstractDoubleSpliterator(
- spliterator.estimateSize(), spliterator.characteristics()) {
- @Override
- public boolean tryAdvance(final DoubleConsumer innerAction) {
- return spliterator.tryAdvance(action.andThen(innerAction));
- }
- };
-
- return new DoubleStreamSource(this, peekSpliterator);
- }
-
- @Override
- public DoubleStream limit(long maxSize) {
- throwIfTerminated();
- checkState(maxSize >= 0, "maxSize may not be negative");
- return new DoubleStreamSource(this, new LimitSpliterator(maxSize, spliterator));
- }
-
- @Override
- public DoubleStream skip(long n) {
- throwIfTerminated();
- checkState(n >= 0, "n may not be negative");
- if (n == 0) {
- return this;
- }
- return new DoubleStreamSource(this, new SkipSpliterator(n, spliterator));
- }
-
- @Override
- public Stream<Double> boxed() {
- return mapToObj(Double::valueOf);
- }
-
- @Override
- public DoubleStream sequential() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public DoubleStream parallel() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public boolean isParallel() {
- throwIfTerminated();
- return false;
- }
-
- @Override
- public DoubleStream unordered() {
- throwIfTerminated();
- return this;
- }
- }
}
diff --git a/user/super/com/google/gwt/emul/java/util/stream/DoubleStreamImpl.java b/user/super/com/google/gwt/emul/java/util/stream/DoubleStreamImpl.java
new file mode 100644
index 0000000..5353a05
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/stream/DoubleStreamImpl.java
@@ -0,0 +1,812 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package java.util.stream;
+
+import static javaemul.internal.InternalPreconditions.checkNotNull;
+import static javaemul.internal.InternalPreconditions.checkState;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.DoubleSummaryStatistics;
+import java.util.HashSet;
+import java.util.OptionalDouble;
+import java.util.PrimitiveIterator;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.DoubleBinaryOperator;
+import java.util.function.DoubleConsumer;
+import java.util.function.DoubleFunction;
+import java.util.function.DoublePredicate;
+import java.util.function.DoubleToIntFunction;
+import java.util.function.DoubleToLongFunction;
+import java.util.function.DoubleUnaryOperator;
+import java.util.function.IntConsumer;
+import java.util.function.LongConsumer;
+import java.util.function.ObjDoubleConsumer;
+import java.util.function.Supplier;
+
+/**
+ * Main implementation of DoubleStream, wrapping a single spliterator, and an optional parent
+ * stream.
+ */
+final class DoubleStreamImpl extends TerminatableStream<DoubleStreamImpl> implements DoubleStream {
+
+ /**
+ * Represents an empty stream, doing nothing for all methods.
+ */
+ static class Empty extends TerminatableStream<Empty> implements DoubleStream {
+ public Empty(TerminatableStream<?> previous) {
+ super(previous);
+ }
+
+ @Override
+ public DoubleStream filter(DoublePredicate predicate) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public DoubleStream map(DoubleUnaryOperator mapper) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper) {
+ throwIfTerminated();
+ return new StreamImpl.Empty<U>(this);
+ }
+
+ @Override
+ public IntStream mapToInt(DoubleToIntFunction mapper) {
+ throwIfTerminated();
+ return new IntStreamImpl.Empty(this);
+ }
+
+ @Override
+ public LongStream mapToLong(DoubleToLongFunction mapper) {
+ throwIfTerminated();
+ return new LongStreamImpl.Empty(this);
+ }
+
+ @Override
+ public DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public DoubleStream distinct() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public DoubleStream sorted() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public DoubleStream peek(DoubleConsumer action) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public DoubleStream limit(long maxSize) {
+ throwIfTerminated();
+ checkState(maxSize >= 0, "maxSize may not be negative");
+ return this;
+ }
+
+ @Override
+ public DoubleStream skip(long n) {
+ throwIfTerminated();
+ checkState(n >= 0, "n may not be negative");
+ return this;
+ }
+
+ @Override
+ public void forEach(DoubleConsumer action) {
+ terminate();
+ // do nothing
+ }
+
+ @Override
+ public void forEachOrdered(DoubleConsumer action) {
+ terminate();
+ // do nothing
+ }
+
+ @Override
+ public double[] toArray() {
+ terminate();
+ return new double[0];
+ }
+
+ @Override
+ public double reduce(double identity, DoubleBinaryOperator op) {
+ terminate();
+ return identity;
+ }
+
+ @Override
+ public OptionalDouble reduce(DoubleBinaryOperator op) {
+ terminate();
+ return OptionalDouble.empty();
+ }
+
+ @Override
+ public <R> R collect(
+ Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> combiner) {
+ terminate();
+ return supplier.get();
+ }
+
+ @Override
+ public double sum() {
+ terminate();
+ return 0;
+ }
+
+ @Override
+ public OptionalDouble min() {
+ terminate();
+ return OptionalDouble.empty();
+ }
+
+ @Override
+ public OptionalDouble max() {
+ terminate();
+ return OptionalDouble.empty();
+ }
+
+ @Override
+ public long count() {
+ terminate();
+ return 0;
+ }
+
+ @Override
+ public OptionalDouble average() {
+ terminate();
+ return OptionalDouble.empty();
+ }
+
+ @Override
+ public DoubleSummaryStatistics summaryStatistics() {
+ terminate();
+ return new DoubleSummaryStatistics();
+ }
+
+ @Override
+ public boolean anyMatch(DoublePredicate predicate) {
+ terminate();
+ return false;
+ }
+
+ @Override
+ public boolean allMatch(DoublePredicate predicate) {
+ terminate();
+ return true;
+ }
+
+ @Override
+ public boolean noneMatch(DoublePredicate predicate) {
+ terminate();
+ return true;
+ }
+
+ @Override
+ public OptionalDouble findFirst() {
+ terminate();
+ return OptionalDouble.empty();
+ }
+
+ @Override
+ public OptionalDouble findAny() {
+ terminate();
+ return OptionalDouble.empty();
+ }
+
+ @Override
+ public Stream<Double> boxed() {
+ throwIfTerminated();
+ return new StreamImpl.Empty<Double>(this);
+ }
+
+ @Override
+ public DoubleStream sequential() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public DoubleStream parallel() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public PrimitiveIterator.OfDouble iterator() {
+ return Spliterators.iterator(spliterator());
+ }
+
+ @Override
+ public Spliterator.OfDouble spliterator() {
+ terminate();
+ return Spliterators.emptyDoubleSpliterator();
+ }
+
+ @Override
+ public boolean isParallel() {
+ throwIfTerminated();
+ return false;
+ }
+
+ @Override
+ public DoubleStream unordered() {
+ throwIfTerminated();
+ return this;
+ }
+ }
+
+ /**
+ * Double to Int map spliterator.
+ */
+ private static final class MapToIntSpliterator extends Spliterators.AbstractIntSpliterator {
+ private final DoubleToIntFunction map;
+ private final Spliterator.OfDouble original;
+
+ public MapToIntSpliterator(DoubleToIntFunction map, Spliterator.OfDouble original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final IntConsumer action) {
+ return original.tryAdvance((double u) -> action.accept(map.applyAsInt(u)));
+ }
+ }
+
+ /**
+ * Double to Object map spliterator.
+ *
+ * @param <T> the type of Object in the spliterator
+ */
+ private static final class MapToObjSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
+ private final DoubleFunction<? extends T> map;
+ private final Spliterator.OfDouble original;
+
+ public MapToObjSpliterator(DoubleFunction<? extends T> map, Spliterator.OfDouble original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final Consumer<? super T> action) {
+ return original.tryAdvance((double u) -> action.accept(map.apply(u)));
+ }
+ }
+
+ /**
+ * Double to Long map spliterator.
+ */
+ private static final class MapToLongSpliterator extends Spliterators.AbstractLongSpliterator {
+ private final DoubleToLongFunction map;
+ private final Spliterator.OfDouble original;
+
+ public MapToLongSpliterator(DoubleToLongFunction map, Spliterator.OfDouble original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final LongConsumer action) {
+ return original.tryAdvance((double u) -> action.accept(map.applyAsLong(u)));
+ }
+ }
+
+ /**
+ * Double to Double map spliterator.
+ */
+ private static final class MapToDoubleSpliterator extends Spliterators.AbstractDoubleSpliterator {
+ private final DoubleUnaryOperator map;
+ private final Spliterator.OfDouble original;
+
+ public MapToDoubleSpliterator(DoubleUnaryOperator map, Spliterator.OfDouble original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final DoubleConsumer action) {
+ return original.tryAdvance((double u) -> action.accept(map.applyAsDouble(u)));
+ }
+ }
+
+ /**
+ * Double filter spliterator.
+ */
+ private static final class FilterSpliterator extends Spliterators.AbstractDoubleSpliterator {
+ private final DoublePredicate filter;
+ private final Spliterator.OfDouble original;
+
+ private boolean found;
+
+ public FilterSpliterator(DoublePredicate filter, Spliterator.OfDouble original) {
+ super(original.estimateSize(), original.characteristics() & ~Spliterator.SIZED);
+ checkNotNull(filter);
+ this.filter = filter;
+ this.original = original;
+ }
+
+ @Override
+ public Comparator<? super Double> getComparator() {
+ return original.getComparator();
+ }
+
+ @Override
+ public boolean tryAdvance(final DoubleConsumer action) {
+ found = false;
+ while (!found
+ && original.tryAdvance(
+ (double item) -> {
+ if (filter.test(item)) {
+ found = true;
+ action.accept(item);
+ }
+ })) {
+ // do nothing, work is done in tryAdvance
+ }
+
+ return found;
+ }
+ }
+
+ /**
+ * Double skip spliterator.
+ */
+ private static final class SkipSpliterator extends Spliterators.AbstractDoubleSpliterator {
+ private long skip;
+ private final Spliterator.OfDouble original;
+
+ public SkipSpliterator(long skip, Spliterator.OfDouble original) {
+ super(
+ original.hasCharacteristics(Spliterator.SIZED)
+ ? Math.max(0, original.estimateSize() - skip)
+ : Long.MAX_VALUE,
+ original.characteristics());
+ this.skip = skip;
+ this.original = original;
+ }
+
+ @Override
+ public Comparator<? super Double> getComparator() {
+ return original.getComparator();
+ }
+
+ @Override
+ public boolean tryAdvance(DoubleConsumer action) {
+ while (skip > 0) {
+ if (!original.tryAdvance((double ignore) -> { })) {
+ return false;
+ }
+ skip--;
+ }
+ return original.tryAdvance(action);
+ }
+ }
+
+ /**
+ * Double limit spliterator.
+ */
+ private static final class LimitSpliterator extends Spliterators.AbstractDoubleSpliterator {
+ private final long limit;
+ private final Spliterator.OfDouble original;
+ private int position = 0;
+
+ public LimitSpliterator(long limit, Spliterator.OfDouble original) {
+ super(
+ original.hasCharacteristics(Spliterator.SIZED)
+ ? Math.min(original.estimateSize(), limit)
+ : Long.MAX_VALUE,
+ original.characteristics());
+ this.limit = limit;
+ this.original = original;
+ }
+
+ @Override
+ public Comparator<? super Double> getComparator() {
+ return original.getComparator();
+ }
+
+ @Override
+ public boolean tryAdvance(DoubleConsumer action) {
+ if (position >= limit) {
+ return false;
+ }
+
+ boolean result = original.tryAdvance(action);
+ position++;
+ return result;
+ }
+ }
+
+ /**
+ * Value holder for various stream operations.
+ */
+ private static class ValueConsumer implements DoubleConsumer {
+ double value;
+
+ @Override
+ public void accept(double value) {
+ this.value = value;
+ }
+ }
+
+ private final Spliterator.OfDouble spliterator;
+
+ public DoubleStreamImpl(TerminatableStream<?> previous, Spliterator.OfDouble spliterator) {
+ super(previous);
+ this.spliterator = spliterator;
+ }
+
+ // terminals
+
+ @Override
+ public void forEach(DoubleConsumer action) {
+ forEachOrdered(action);
+ }
+
+ @Override
+ public void forEachOrdered(DoubleConsumer action) {
+ terminate();
+ spliterator.forEachRemaining(action);
+ }
+
+ @Override
+ public double[] toArray() {
+ terminate();
+ double[] entries = new double[0];
+ // this is legal in js, since the array will be backed by a JS array
+ spliterator.forEachRemaining((double value) -> entries[entries.length] = value);
+
+ return entries;
+ }
+
+ @Override
+ public double reduce(double identity, DoubleBinaryOperator op) {
+ terminate();
+ ValueConsumer holder = new ValueConsumer();
+ holder.value = identity;
+ spliterator.forEachRemaining(
+ (double value) -> {
+ holder.accept(op.applyAsDouble(holder.value, value));
+ });
+ return holder.value;
+ }
+
+ @Override
+ public OptionalDouble reduce(DoubleBinaryOperator op) {
+ ValueConsumer holder = new ValueConsumer();
+ if (spliterator.tryAdvance(holder)) {
+ return OptionalDouble.of(reduce(holder.value, op));
+ }
+ terminate();
+ return OptionalDouble.empty();
+ }
+
+ @Override
+ public <R> R collect(
+ Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> combiner) {
+ terminate();
+ final R acc = supplier.get();
+ spliterator.forEachRemaining((double value) -> accumulator.accept(acc, value));
+ return acc;
+ }
+
+ @Override
+ public double sum() {
+ return summaryStatistics().getSum();
+ }
+
+ @Override
+ public OptionalDouble min() {
+ DoubleSummaryStatistics stats = summaryStatistics();
+ if (stats.getCount() == 0) {
+ return OptionalDouble.empty();
+ }
+ return OptionalDouble.of(stats.getMin());
+ }
+
+ @Override
+ public OptionalDouble max() {
+ DoubleSummaryStatistics stats = summaryStatistics();
+ if (stats.getCount() == 0) {
+ return OptionalDouble.empty();
+ }
+ return OptionalDouble.of(stats.getMax());
+ }
+
+ @Override
+ public long count() {
+ terminate();
+ long count = 0;
+ while (spliterator.tryAdvance((double value) -> { })) {
+ count++;
+ }
+ return count;
+ }
+
+ @Override
+ public OptionalDouble average() {
+ DoubleSummaryStatistics stats = summaryStatistics();
+ if (stats.getCount() == 0) {
+ return OptionalDouble.empty();
+ }
+ return OptionalDouble.of(stats.getAverage());
+ }
+
+ @Override
+ public DoubleSummaryStatistics summaryStatistics() {
+ return collect(
+ DoubleSummaryStatistics::new,
+ // TODO switch to a lambda reference once #9340 is fixed
+ (doubleSummaryStatistics, value) -> doubleSummaryStatistics.accept(value),
+ DoubleSummaryStatistics::combine);
+ }
+
+ @Override
+ public boolean anyMatch(DoublePredicate predicate) {
+ return filter(predicate).findFirst().isPresent();
+ }
+
+ @Override
+ public boolean allMatch(DoublePredicate predicate) {
+ return !anyMatch(predicate.negate());
+ }
+
+ @Override
+ public boolean noneMatch(DoublePredicate predicate) {
+ return !anyMatch(predicate);
+ }
+
+ @Override
+ public OptionalDouble findFirst() {
+ terminate();
+ ValueConsumer holder = new ValueConsumer();
+ if (spliterator.tryAdvance(holder)) {
+ return OptionalDouble.of(holder.value);
+ }
+ return OptionalDouble.empty();
+ }
+
+ @Override
+ public OptionalDouble findAny() {
+ return findFirst();
+ }
+
+ @Override
+ public PrimitiveIterator.OfDouble iterator() {
+ return Spliterators.iterator(spliterator());
+ }
+
+ @Override
+ public Spliterator.OfDouble spliterator() {
+ terminate();
+ return spliterator;
+ }
+
+ // end terminals
+
+ // intermediates
+
+ @Override
+ public DoubleStream filter(DoublePredicate predicate) {
+ throwIfTerminated();
+ return new DoubleStreamImpl(this, new FilterSpliterator(predicate, spliterator));
+ }
+
+ @Override
+ public DoubleStream map(DoubleUnaryOperator mapper) {
+ throwIfTerminated();
+ return new DoubleStreamImpl(this, new MapToDoubleSpliterator(mapper, spliterator));
+ }
+
+ @Override
+ public <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper) {
+ throwIfTerminated();
+ return new StreamImpl<U>(this, new MapToObjSpliterator<U>(mapper, spliterator));
+ }
+
+ @Override
+ public IntStream mapToInt(DoubleToIntFunction mapper) {
+ throwIfTerminated();
+ return new IntStreamImpl(this, new MapToIntSpliterator(mapper, spliterator));
+ }
+
+ @Override
+ public LongStream mapToLong(DoubleToLongFunction mapper) {
+ throwIfTerminated();
+ return new LongStreamImpl(this, new MapToLongSpliterator(mapper, spliterator));
+ }
+
+ @Override
+ public DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper) {
+ throwIfTerminated();
+ final Spliterator<? extends DoubleStream> spliteratorOfStreams =
+ new MapToObjSpliterator<DoubleStream>(mapper, spliterator);
+
+ Spliterator.OfDouble flatMapSpliterator =
+ new Spliterators.AbstractDoubleSpliterator(Long.MAX_VALUE, 0) {
+ DoubleStream nextStream;
+ Spliterator.OfDouble next;
+
+ @Override
+ public boolean tryAdvance(DoubleConsumer action) {
+ // look for a new spliterator
+ while (advanceToNextSpliterator()) {
+ // if we have one, try to read and use it
+ if (next.tryAdvance(action)) {
+ return true;
+ } else {
+ nextStream.close();
+ nextStream = null;
+ // failed, null it out so we can find another
+ next = null;
+ }
+ }
+ return false;
+ }
+
+ private boolean advanceToNextSpliterator() {
+ while (next == null) {
+ if (!spliteratorOfStreams.tryAdvance(
+ n -> {
+ if (n != null) {
+ nextStream = n;
+ next = n.spliterator();
+ }
+ })) {
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+
+ return new DoubleStreamImpl(this, flatMapSpliterator);
+ }
+
+ @Override
+ public DoubleStream distinct() {
+ throwIfTerminated();
+ HashSet<Double> seen = new HashSet<>();
+ return filter(seen::add);
+ }
+
+ @Override
+ public DoubleStream sorted() {
+ throwIfTerminated();
+
+ Spliterator.OfDouble sortingSpliterator =
+ new Spliterators.AbstractDoubleSpliterator(
+ spliterator.estimateSize(), spliterator.characteristics() | Spliterator.SORTED) {
+ Spliterator.OfDouble ordered = null;
+
+ @Override
+ public Comparator<? super Double> getComparator() {
+ return null;
+ }
+
+ @Override
+ public boolean tryAdvance(DoubleConsumer action) {
+ if (ordered == null) {
+ double[] list = new double[0];
+ spliterator.forEachRemaining((double item) -> list[list.length] = item);
+ Arrays.sort(list);
+ ordered = Spliterators.spliterator(list, characteristics());
+ }
+ return ordered.tryAdvance(action);
+ }
+ };
+
+ return new DoubleStreamImpl(this, sortingSpliterator);
+ }
+
+ @Override
+ public DoubleStream peek(DoubleConsumer action) {
+ checkNotNull(action);
+ throwIfTerminated();
+
+ Spliterator.OfDouble peekSpliterator =
+ new Spliterators.AbstractDoubleSpliterator(
+ spliterator.estimateSize(), spliterator.characteristics()) {
+ @Override
+ public boolean tryAdvance(final DoubleConsumer innerAction) {
+ return spliterator.tryAdvance(action.andThen(innerAction));
+ }
+ };
+
+ return new DoubleStreamImpl(this, peekSpliterator);
+ }
+
+ @Override
+ public DoubleStream limit(long maxSize) {
+ throwIfTerminated();
+ checkState(maxSize >= 0, "maxSize may not be negative");
+ return new DoubleStreamImpl(this, new LimitSpliterator(maxSize, spliterator));
+ }
+
+ @Override
+ public DoubleStream skip(long n) {
+ throwIfTerminated();
+ checkState(n >= 0, "n may not be negative");
+ if (n == 0) {
+ return this;
+ }
+ return new DoubleStreamImpl(this, new SkipSpliterator(n, spliterator));
+ }
+
+ @Override
+ public Stream<Double> boxed() {
+ return mapToObj(Double::valueOf);
+ }
+
+ @Override
+ public DoubleStream sequential() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public DoubleStream parallel() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public boolean isParallel() {
+ throwIfTerminated();
+ return false;
+ }
+
+ @Override
+ public DoubleStream unordered() {
+ throwIfTerminated();
+ return this;
+ }
+}
diff --git a/user/super/com/google/gwt/emul/java/util/stream/IntStream.java b/user/super/com/google/gwt/emul/java/util/stream/IntStream.java
index 1a2b3fd..efd9ef4 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/IntStream.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/IntStream.java
@@ -13,15 +13,12 @@
* License for the specific language governing permissions and limitations under
* the License.
*/
-
package java.util.stream;
-import static javaemul.internal.InternalPreconditions.checkNotNull;
import static javaemul.internal.InternalPreconditions.checkState;
import java.util.Arrays;
import java.util.Comparator;
-import java.util.HashSet;
import java.util.IntSummaryStatistics;
import java.util.OptionalDouble;
import java.util.OptionalInt;
@@ -30,8 +27,6 @@
import java.util.Spliterators;
import java.util.Spliterators.AbstractIntSpliterator;
import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-import java.util.function.DoubleConsumer;
import java.util.function.IntBinaryOperator;
import java.util.function.IntConsumer;
import java.util.function.IntFunction;
@@ -40,7 +35,6 @@
import java.util.function.IntToDoubleFunction;
import java.util.function.IntToLongFunction;
import java.util.function.IntUnaryOperator;
-import java.util.function.LongConsumer;
import java.util.function.ObjIntConsumer;
import java.util.function.Supplier;
@@ -51,18 +45,23 @@
public interface IntStream extends BaseStream<Integer, IntStream> {
/**
- * Value holder for various stream operations.
+ * See <a
+ * href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.Builder.html">the
+ * official Java API doc</a> for details.
*/
- static final class ValueConsumer implements IntConsumer {
- int value;
-
+ interface Builder extends IntConsumer {
@Override
- public void accept(int value) {
- this.value = value;
+ void accept(int t);
+
+ default IntStream.Builder add(int t) {
+ accept(t);
+ return this;
}
+
+ IntStream build();
}
- static IntStream.Builder builder() {
+ static Builder builder() {
return new Builder() {
private int[] items = new int[0];
@@ -126,7 +125,7 @@
}
};
- IntStream result = new IntStreamSource(null, spliterator);
+ IntStream result = new IntStreamImpl(null, spliterator);
result.onClose(a::close);
result.onClose(b::close);
@@ -135,7 +134,7 @@
}
static IntStream empty() {
- return new EmptyIntStreamSource(null);
+ return new IntStreamImpl.Empty(null);
}
static IntStream generate(final IntSupplier s) {
@@ -221,23 +220,6 @@
return StreamSupport.intStream(spliterator, false);
}
- /**
- * See
- * <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.Builder.html">
- * the official Java API doc</a> for details.
- */
- public interface Builder extends IntConsumer {
- @Override
- void accept(int t);
-
- default IntStream.Builder add(int t) {
- accept(t);
- return this;
- }
-
- IntStream build();
- }
-
boolean allMatch(IntPredicate predicate);
boolean anyMatch(IntPredicate predicate);
@@ -311,781 +293,4 @@
IntSummaryStatistics summaryStatistics();
int[] toArray();
-
- /**
- * Represents an empty stream, doing nothing for all methods.
- */
- static class EmptyIntStreamSource extends TerminatableStream<EmptyIntStreamSource>
- implements IntStream {
- public EmptyIntStreamSource(TerminatableStream<?> previous) {
- super(previous);
- }
-
- @Override
- public IntStream filter(IntPredicate predicate) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public IntStream map(IntUnaryOperator mapper) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public <U> Stream<U> mapToObj(IntFunction<? extends U> mapper) {
- throwIfTerminated();
- return new Stream.EmptyStreamSource<U>(this);
- }
-
- @Override
- public LongStream mapToLong(IntToLongFunction mapper) {
- throwIfTerminated();
- return new LongStream.EmptyLongStreamSource(this);
- }
-
- @Override
- public DoubleStream mapToDouble(IntToDoubleFunction mapper) {
- throwIfTerminated();
- return new DoubleStream.EmptyDoubleStreamSource(this);
- }
-
- @Override
- public IntStream flatMap(IntFunction<? extends IntStream> mapper) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public IntStream distinct() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public IntStream sorted() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public IntStream peek(IntConsumer action) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public IntStream limit(long maxSize) {
- throwIfTerminated();
- checkState(maxSize >= 0, "maxSize may not be negative");
- return this;
- }
-
- @Override
- public IntStream skip(long n) {
- throwIfTerminated();
- checkState(n >= 0, "n may not be negative");
- return this;
- }
-
- @Override
- public void forEach(IntConsumer action) {
- terminate();
- // do nothing
- }
-
- @Override
- public void forEachOrdered(IntConsumer action) {
- terminate();
- // do nothing
- }
-
- @Override
- public int[] toArray() {
- terminate();
- return new int[0];
- }
-
- @Override
- public int reduce(int identity, IntBinaryOperator op) {
- terminate();
- return identity;
- }
-
- @Override
- public OptionalInt reduce(IntBinaryOperator op) {
- terminate();
- return OptionalInt.empty();
- }
-
- @Override
- public <R> R collect(
- Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner) {
- terminate();
- return supplier.get();
- }
-
- @Override
- public int sum() {
- terminate();
- return 0;
- }
-
- @Override
- public OptionalInt min() {
- terminate();
- return OptionalInt.empty();
- }
-
- @Override
- public OptionalInt max() {
- terminate();
- return OptionalInt.empty();
- }
-
- @Override
- public long count() {
- terminate();
- return 0;
- }
-
- @Override
- public OptionalDouble average() {
- terminate();
- return OptionalDouble.empty();
- }
-
- @Override
- public IntSummaryStatistics summaryStatistics() {
- terminate();
- return new IntSummaryStatistics();
- }
-
- @Override
- public boolean anyMatch(IntPredicate predicate) {
- terminate();
- return false;
- }
-
- @Override
- public boolean allMatch(IntPredicate predicate) {
- terminate();
- return true;
- }
-
- @Override
- public boolean noneMatch(IntPredicate predicate) {
- terminate();
- return true;
- }
-
- @Override
- public OptionalInt findFirst() {
- terminate();
- return OptionalInt.empty();
- }
-
- @Override
- public OptionalInt findAny() {
- terminate();
- return OptionalInt.empty();
- }
-
- @Override
- public LongStream asLongStream() {
- throwIfTerminated();
- return new LongStream.EmptyLongStreamSource(this);
- }
-
- @Override
- public DoubleStream asDoubleStream() {
- throwIfTerminated();
- return new DoubleStream.EmptyDoubleStreamSource(this);
- }
-
- @Override
- public Stream<Integer> boxed() {
- throwIfTerminated();
- return new Stream.EmptyStreamSource<Integer>(this);
- }
-
- @Override
- public IntStream sequential() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public IntStream parallel() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public PrimitiveIterator.OfInt iterator() {
- return Spliterators.iterator(spliterator());
- }
-
- @Override
- public Spliterator.OfInt spliterator() {
- terminate();
- return Spliterators.emptyIntSpliterator();
- }
-
- @Override
- public boolean isParallel() {
- throwIfTerminated();
- return false;
- }
-
- @Override
- public IntStream unordered() {
- throwIfTerminated();
- return this;
- }
- }
-
- /**
- * Int to Int map spliterator.
- */
- static final class MapToIntSpliterator extends Spliterators.AbstractIntSpliterator {
- private final IntUnaryOperator map;
- private final Spliterator.OfInt original;
-
- public MapToIntSpliterator(IntUnaryOperator map, Spliterator.OfInt original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final IntConsumer action) {
- return original.tryAdvance((int u) -> action.accept(map.applyAsInt(u)));
- }
- }
-
- /**
- * Int to Object map spliterator.
- * @param <T> the type of data in the object spliterator
- */
- static final class MapToObjSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
- private final IntFunction<? extends T> map;
- private final Spliterator.OfInt original;
-
- public MapToObjSpliterator(IntFunction<? extends T> map, Spliterator.OfInt original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final Consumer<? super T> action) {
- return original.tryAdvance((int u) -> action.accept(map.apply(u)));
- }
- }
-
- /**
- * Int to Long map spliterator.
- */
- static final class MapToLongSpliterator extends Spliterators.AbstractLongSpliterator {
- private final IntToLongFunction map;
- private final Spliterator.OfInt original;
-
- public MapToLongSpliterator(IntToLongFunction map, Spliterator.OfInt original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final LongConsumer action) {
- return original.tryAdvance((int u) -> action.accept(map.applyAsLong(u)));
- }
- }
-
- /**
- * Int to Double map spliterator.
- */
- static final class MapToDoubleSpliterator extends Spliterators.AbstractDoubleSpliterator {
- private final IntToDoubleFunction map;
- private final Spliterator.OfInt original;
-
- public MapToDoubleSpliterator(IntToDoubleFunction map, Spliterator.OfInt original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final DoubleConsumer action) {
- return original.tryAdvance((int u) -> action.accept(map.applyAsDouble(u)));
- }
- }
-
- /**
- * Int filter spliterator.
- */
- static final class FilterSpliterator extends Spliterators.AbstractIntSpliterator {
- private final IntPredicate filter;
- private final Spliterator.OfInt original;
-
- private boolean found;
-
- public FilterSpliterator(IntPredicate filter, Spliterator.OfInt original) {
- super(original.estimateSize(), original.characteristics() & ~Spliterator.SIZED);
- checkNotNull(filter);
- this.filter = filter;
- this.original = original;
- }
-
- @Override
- public Comparator<? super Integer> getComparator() {
- return original.getComparator();
- }
-
- @Override
- public boolean tryAdvance(final IntConsumer action) {
- found = false;
- while (!found
- && original.tryAdvance(
- (int item) -> {
- if (filter.test(item)) {
- found = true;
- action.accept(item);
- }
- })) {
- // do nothing, work is done in tryAdvance
- }
-
- return found;
- }
- }
-
- /**
- * Int skip spliterator.
- */
- static final class SkipSpliterator extends Spliterators.AbstractIntSpliterator {
- private long skip;
- private final Spliterator.OfInt original;
-
- public SkipSpliterator(long skip, Spliterator.OfInt original) {
- super(
- original.hasCharacteristics(Spliterator.SIZED)
- ? Math.max(0, original.estimateSize() - skip)
- : Long.MAX_VALUE,
- original.characteristics());
- this.skip = skip;
- this.original = original;
- }
-
- @Override
- public Comparator<? super Integer> getComparator() {
- return original.getComparator();
- }
-
- @Override
- public boolean tryAdvance(IntConsumer action) {
- while (skip > 0) {
- if (!original.tryAdvance((int ignore) -> { })) {
- return false;
- }
- skip--;
- }
- return original.tryAdvance(action);
- }
- }
-
- /**
- * Int limit spliterator.
- */
- static final class LimitSpliterator extends Spliterators.AbstractIntSpliterator {
- private final long limit;
- private final Spliterator.OfInt original;
- private int position = 0;
-
- public LimitSpliterator(long limit, Spliterator.OfInt original) {
- super(
- original.hasCharacteristics(Spliterator.SIZED)
- ? Math.min(original.estimateSize(), limit)
- : Long.MAX_VALUE,
- original.characteristics());
- this.limit = limit;
- this.original = original;
- }
-
- @Override
- public Comparator<? super Integer> getComparator() {
- return original.getComparator();
- }
-
- @Override
- public boolean tryAdvance(IntConsumer action) {
- if (position >= limit) {
- return false;
- }
- boolean result = original.tryAdvance(action);
- position++;
- return result;
- }
- }
-
- /**
- * Main implementation of IntStream, wrapping a single spliterator, and an optional parent stream.
- */
- static class IntStreamSource extends TerminatableStream<IntStreamSource> implements IntStream {
- private final Spliterator.OfInt spliterator;
-
- public IntStreamSource(TerminatableStream<?> previous, Spliterator.OfInt spliterator) {
- super(previous);
- this.spliterator = spliterator;
- }
-
- // terminals
- @Override
- public Spliterator.OfInt spliterator() {
- terminate();
- return spliterator;
- }
-
- @Override
- public PrimitiveIterator.OfInt iterator() {
- return Spliterators.iterator(spliterator());
- }
-
- @Override
- public OptionalInt findFirst() {
- terminate();
- ValueConsumer holder = new ValueConsumer();
- if (spliterator.tryAdvance(holder)) {
- return OptionalInt.of(holder.value);
- }
- return OptionalInt.empty();
- }
-
- @Override
- public OptionalInt findAny() {
- return findFirst();
- }
-
- @Override
- public boolean noneMatch(IntPredicate predicate) {
- return !anyMatch(predicate);
- }
-
- @Override
- public boolean allMatch(IntPredicate predicate) {
- return !anyMatch(predicate.negate());
- }
-
- @Override
- public boolean anyMatch(IntPredicate predicate) {
- return filter(predicate).findFirst().isPresent();
- }
-
- @Override
- public IntSummaryStatistics summaryStatistics() {
- return collect(
- IntSummaryStatistics::new,
- // TODO switch to a lambda reference once #9340 is fixed
- (intSummaryStatistics, value) -> intSummaryStatistics.accept(value),
- IntSummaryStatistics::combine);
- }
-
- @Override
- public OptionalDouble average() {
- IntSummaryStatistics stats = summaryStatistics();
- if (stats.getCount() == 0) {
- return OptionalDouble.empty();
- }
- return OptionalDouble.of(stats.getAverage());
- }
-
- @Override
- public long count() {
- terminate();
- long count = 0;
- while (spliterator.tryAdvance((int value) -> { })) {
- count++;
- }
- return count;
- }
-
- @Override
- public OptionalInt max() {
- IntSummaryStatistics stats = summaryStatistics();
- if (stats.getCount() == 0) {
- return OptionalInt.empty();
- }
- return OptionalInt.of(stats.getMax());
- }
-
- @Override
- public OptionalInt min() {
- IntSummaryStatistics stats = summaryStatistics();
- if (stats.getCount() == 0) {
- return OptionalInt.empty();
- }
- return OptionalInt.of(stats.getMin());
- }
-
- @Override
- public int sum() {
- return (int) summaryStatistics().getSum();
- }
-
- @Override
- public <R> R collect(
- Supplier<R> supplier, final ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner) {
- terminate();
- final R acc = supplier.get();
- spliterator.forEachRemaining((int value) -> accumulator.accept(acc, value));
- return acc;
- }
-
- @Override
- public OptionalInt reduce(IntBinaryOperator op) {
- ValueConsumer holder = new ValueConsumer();
- if (spliterator.tryAdvance(holder)) {
- return OptionalInt.of(reduce(holder.value, op));
- }
- terminate();
- return OptionalInt.empty();
- }
-
- @Override
- public int reduce(int identity, IntBinaryOperator op) {
- terminate();
- ValueConsumer holder = new ValueConsumer();
- holder.value = identity;
- spliterator.forEachRemaining(
- (int value) -> {
- holder.accept(op.applyAsInt(holder.value, value));
- });
- return holder.value;
- }
-
- @Override
- public int[] toArray() {
- terminate();
- int[] entries = new int[0];
- // this is legal in js, since the array will be backed by a JS array
- spliterator.forEachRemaining((int value) -> entries[entries.length] = value);
-
- return entries;
- }
-
- @Override
- public void forEachOrdered(IntConsumer action) {
- terminate();
- spliterator.forEachRemaining(action);
- }
-
- @Override
- public void forEach(IntConsumer action) {
- forEachOrdered(action);
- }
- // end terminals
-
- // intermediates
-
- @Override
- public IntStream filter(IntPredicate predicate) {
- throwIfTerminated();
- return new IntStreamSource(this, new FilterSpliterator(predicate, spliterator));
- }
-
- @Override
- public IntStream map(IntUnaryOperator mapper) {
- throwIfTerminated();
- return new IntStreamSource(this, new MapToIntSpliterator(mapper, spliterator));
- }
-
- @Override
- public <U> Stream<U> mapToObj(IntFunction<? extends U> mapper) {
- throwIfTerminated();
- return new Stream.StreamSource<U>(this, new MapToObjSpliterator<U>(mapper, spliterator));
- }
-
- @Override
- public LongStream mapToLong(IntToLongFunction mapper) {
- throwIfTerminated();
- return new LongStream.LongStreamSource(this, new MapToLongSpliterator(mapper, spliterator));
- }
-
- @Override
- public DoubleStream mapToDouble(IntToDoubleFunction mapper) {
- throwIfTerminated();
- return new DoubleStream.DoubleStreamSource(
- this, new MapToDoubleSpliterator(mapper, spliterator));
- }
-
- @Override
- public IntStream flatMap(IntFunction<? extends IntStream> mapper) {
- throwIfTerminated();
- final Spliterator<? extends IntStream> spliteratorOfStreams =
- new MapToObjSpliterator<>(mapper, spliterator);
-
- Spliterator.OfInt flatMapSpliterator =
- new Spliterators.AbstractIntSpliterator(Long.MAX_VALUE, 0) {
- IntStream nextStream;
- Spliterator.OfInt next;
-
- @Override
- public boolean tryAdvance(IntConsumer action) {
- // look for a new spliterator
- while (advanceToNextSpliterator()) {
- // if we have one, try to read and use it
- if (next.tryAdvance(action)) {
- return true;
- } else {
- nextStream.close();
- nextStream = null;
- // failed, null it out so we can find another
- next = null;
- }
- }
- return false;
- }
-
- private boolean advanceToNextSpliterator() {
- while (next == null) {
- if (!spliteratorOfStreams.tryAdvance(
- n -> {
- if (n != null) {
- nextStream = n;
- next = n.spliterator();
- }
- })) {
- return false;
- }
- }
- return true;
- }
- };
-
- return new IntStreamSource(this, flatMapSpliterator);
- }
-
- @Override
- public IntStream distinct() {
- throwIfTerminated();
- HashSet<Integer> seen = new HashSet<>();
- return filter(seen::add);
- }
-
- @Override
- public IntStream sorted() {
- throwIfTerminated();
-
- AbstractIntSpliterator sortedSpliterator =
- new Spliterators.AbstractIntSpliterator(
- spliterator.estimateSize(), spliterator.characteristics() | Spliterator.SORTED) {
- Spliterator.OfInt ordered = null;
-
- @Override
- public Comparator<? super Integer> getComparator() {
- return null;
- }
-
- @Override
- public boolean tryAdvance(IntConsumer action) {
- if (ordered == null) {
- int[] list = new int[0];
- spliterator.forEachRemaining((int item) -> list[list.length] = item);
- Arrays.sort(list);
- ordered = Spliterators.spliterator(list, characteristics());
- }
- return ordered.tryAdvance(action);
- }
- };
-
- return new IntStreamSource(this, sortedSpliterator);
- }
-
- @Override
- public IntStream peek(IntConsumer action) {
- checkNotNull(action);
- throwIfTerminated();
-
- AbstractIntSpliterator peekSpliterator =
- new Spliterators.AbstractIntSpliterator(
- spliterator.estimateSize(), spliterator.characteristics()) {
- @Override
- public boolean tryAdvance(final IntConsumer innerAction) {
- return spliterator.tryAdvance(action.andThen(innerAction));
- }
- };
-
- return new IntStreamSource(this, peekSpliterator);
- }
-
- @Override
- public IntStream limit(long maxSize) {
- throwIfTerminated();
- checkState(maxSize >= 0, "maxSize may not be negative");
- return new IntStreamSource(this, new LimitSpliterator(maxSize, spliterator));
- }
-
- @Override
- public IntStream skip(long n) {
- throwIfTerminated();
- checkState(n >= 0, "n may not be negative");
- if (n == 0) {
- return this;
- }
- return new IntStreamSource(this, new SkipSpliterator(n, spliterator));
- }
-
- @Override
- public LongStream asLongStream() {
- return mapToLong(i -> (long) i);
- }
-
- @Override
- public DoubleStream asDoubleStream() {
- return mapToDouble(i -> (double) i);
- }
-
- @Override
- public Stream<Integer> boxed() {
- return mapToObj(Integer::valueOf);
- }
-
- @Override
- public IntStream sequential() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public IntStream parallel() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public boolean isParallel() {
- throwIfTerminated();
- return false;
- }
-
- @Override
- public IntStream unordered() {
- throwIfTerminated();
- return this;
- }
- }
}
diff --git a/user/super/com/google/gwt/emul/java/util/stream/IntStreamImpl.java b/user/super/com/google/gwt/emul/java/util/stream/IntStreamImpl.java
new file mode 100644
index 0000000..6839314
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/stream/IntStreamImpl.java
@@ -0,0 +1,832 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package java.util.stream;
+
+import static javaemul.internal.InternalPreconditions.checkNotNull;
+import static javaemul.internal.InternalPreconditions.checkState;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.IntSummaryStatistics;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.PrimitiveIterator;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.Spliterators.AbstractIntSpliterator;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.DoubleConsumer;
+import java.util.function.IntBinaryOperator;
+import java.util.function.IntConsumer;
+import java.util.function.IntFunction;
+import java.util.function.IntPredicate;
+import java.util.function.IntToDoubleFunction;
+import java.util.function.IntToLongFunction;
+import java.util.function.IntUnaryOperator;
+import java.util.function.LongConsumer;
+import java.util.function.ObjIntConsumer;
+import java.util.function.Supplier;
+
+/**
+ * Main implementation of IntStream, wrapping a single spliterator, and an optional parent stream.
+ */
+final class IntStreamImpl extends TerminatableStream<IntStreamImpl> implements IntStream {
+
+ /**
+ * Represents an empty stream, doing nothing for all methods.
+ */
+ static class Empty extends TerminatableStream<Empty> implements IntStream {
+ public Empty(TerminatableStream<?> previous) {
+ super(previous);
+ }
+
+ @Override
+ public IntStream filter(IntPredicate predicate) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public IntStream map(IntUnaryOperator mapper) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public <U> Stream<U> mapToObj(IntFunction<? extends U> mapper) {
+ throwIfTerminated();
+ return new StreamImpl.Empty<U>(this);
+ }
+
+ @Override
+ public LongStream mapToLong(IntToLongFunction mapper) {
+ throwIfTerminated();
+ return new LongStreamImpl.Empty(this);
+ }
+
+ @Override
+ public DoubleStream mapToDouble(IntToDoubleFunction mapper) {
+ throwIfTerminated();
+ return new DoubleStreamImpl.Empty(this);
+ }
+
+ @Override
+ public IntStream flatMap(IntFunction<? extends IntStream> mapper) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public IntStream distinct() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public IntStream sorted() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public IntStream peek(IntConsumer action) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public IntStream limit(long maxSize) {
+ throwIfTerminated();
+ checkState(maxSize >= 0, "maxSize may not be negative");
+ return this;
+ }
+
+ @Override
+ public IntStream skip(long n) {
+ throwIfTerminated();
+ checkState(n >= 0, "n may not be negative");
+ return this;
+ }
+
+ @Override
+ public void forEach(IntConsumer action) {
+ terminate();
+ // do nothing
+ }
+
+ @Override
+ public void forEachOrdered(IntConsumer action) {
+ terminate();
+ // do nothing
+ }
+
+ @Override
+ public int[] toArray() {
+ terminate();
+ return new int[0];
+ }
+
+ @Override
+ public int reduce(int identity, IntBinaryOperator op) {
+ terminate();
+ return identity;
+ }
+
+ @Override
+ public OptionalInt reduce(IntBinaryOperator op) {
+ terminate();
+ return OptionalInt.empty();
+ }
+
+ @Override
+ public <R> R collect(
+ Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner) {
+ terminate();
+ return supplier.get();
+ }
+
+ @Override
+ public int sum() {
+ terminate();
+ return 0;
+ }
+
+ @Override
+ public OptionalInt min() {
+ terminate();
+ return OptionalInt.empty();
+ }
+
+ @Override
+ public OptionalInt max() {
+ terminate();
+ return OptionalInt.empty();
+ }
+
+ @Override
+ public long count() {
+ terminate();
+ return 0;
+ }
+
+ @Override
+ public OptionalDouble average() {
+ terminate();
+ return OptionalDouble.empty();
+ }
+
+ @Override
+ public IntSummaryStatistics summaryStatistics() {
+ terminate();
+ return new IntSummaryStatistics();
+ }
+
+ @Override
+ public boolean anyMatch(IntPredicate predicate) {
+ terminate();
+ return false;
+ }
+
+ @Override
+ public boolean allMatch(IntPredicate predicate) {
+ terminate();
+ return true;
+ }
+
+ @Override
+ public boolean noneMatch(IntPredicate predicate) {
+ terminate();
+ return true;
+ }
+
+ @Override
+ public OptionalInt findFirst() {
+ terminate();
+ return OptionalInt.empty();
+ }
+
+ @Override
+ public OptionalInt findAny() {
+ terminate();
+ return OptionalInt.empty();
+ }
+
+ @Override
+ public LongStream asLongStream() {
+ throwIfTerminated();
+ return new LongStreamImpl.Empty(this);
+ }
+
+ @Override
+ public DoubleStream asDoubleStream() {
+ throwIfTerminated();
+ return new DoubleStreamImpl.Empty(this);
+ }
+
+ @Override
+ public Stream<Integer> boxed() {
+ throwIfTerminated();
+ return new StreamImpl.Empty<Integer>(this);
+ }
+
+ @Override
+ public IntStream sequential() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public IntStream parallel() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public PrimitiveIterator.OfInt iterator() {
+ return Spliterators.iterator(spliterator());
+ }
+
+ @Override
+ public Spliterator.OfInt spliterator() {
+ terminate();
+ return Spliterators.emptyIntSpliterator();
+ }
+
+ @Override
+ public boolean isParallel() {
+ throwIfTerminated();
+ return false;
+ }
+
+ @Override
+ public IntStream unordered() {
+ throwIfTerminated();
+ return this;
+ }
+ }
+
+ /**
+ * Int to Int map spliterator.
+ */
+ private static final class MapToIntSpliterator extends Spliterators.AbstractIntSpliterator {
+ private final IntUnaryOperator map;
+ private final Spliterator.OfInt original;
+
+ public MapToIntSpliterator(IntUnaryOperator map, Spliterator.OfInt original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final IntConsumer action) {
+ return original.tryAdvance((int u) -> action.accept(map.applyAsInt(u)));
+ }
+ }
+
+ /**
+ * Int to Object map spliterator.
+ *
+ * @param <T> the type of data in the object spliterator
+ */
+ private static final class MapToObjSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
+ private final IntFunction<? extends T> map;
+ private final Spliterator.OfInt original;
+
+ public MapToObjSpliterator(IntFunction<? extends T> map, Spliterator.OfInt original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final Consumer<? super T> action) {
+ return original.tryAdvance((int u) -> action.accept(map.apply(u)));
+ }
+ }
+
+ /**
+ * Int to Long map spliterator.
+ */
+ private static final class MapToLongSpliterator extends Spliterators.AbstractLongSpliterator {
+ private final IntToLongFunction map;
+ private final Spliterator.OfInt original;
+
+ public MapToLongSpliterator(IntToLongFunction map, Spliterator.OfInt original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final LongConsumer action) {
+ return original.tryAdvance((int u) -> action.accept(map.applyAsLong(u)));
+ }
+ }
+
+ /**
+ * Int to Double map spliterator.
+ */
+ private static final class MapToDoubleSpliterator extends Spliterators.AbstractDoubleSpliterator {
+ private final IntToDoubleFunction map;
+ private final Spliterator.OfInt original;
+
+ public MapToDoubleSpliterator(IntToDoubleFunction map, Spliterator.OfInt original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final DoubleConsumer action) {
+ return original.tryAdvance((int u) -> action.accept(map.applyAsDouble(u)));
+ }
+ }
+
+ /**
+ * Int filter spliterator.
+ */
+ private static final class FilterSpliterator extends Spliterators.AbstractIntSpliterator {
+ private final IntPredicate filter;
+ private final Spliterator.OfInt original;
+
+ private boolean found;
+
+ public FilterSpliterator(IntPredicate filter, Spliterator.OfInt original) {
+ super(original.estimateSize(), original.characteristics() & ~Spliterator.SIZED);
+ checkNotNull(filter);
+ this.filter = filter;
+ this.original = original;
+ }
+
+ @Override
+ public Comparator<? super Integer> getComparator() {
+ return original.getComparator();
+ }
+
+ @Override
+ public boolean tryAdvance(final IntConsumer action) {
+ found = false;
+ while (!found
+ && original.tryAdvance(
+ (int item) -> {
+ if (filter.test(item)) {
+ found = true;
+ action.accept(item);
+ }
+ })) {
+ // do nothing, work is done in tryAdvance
+ }
+
+ return found;
+ }
+ }
+
+ /**
+ * Int skip spliterator.
+ */
+ private static final class SkipSpliterator extends Spliterators.AbstractIntSpliterator {
+ private long skip;
+ private final Spliterator.OfInt original;
+
+ public SkipSpliterator(long skip, Spliterator.OfInt original) {
+ super(
+ original.hasCharacteristics(Spliterator.SIZED)
+ ? Math.max(0, original.estimateSize() - skip)
+ : Long.MAX_VALUE,
+ original.characteristics());
+ this.skip = skip;
+ this.original = original;
+ }
+
+ @Override
+ public Comparator<? super Integer> getComparator() {
+ return original.getComparator();
+ }
+
+ @Override
+ public boolean tryAdvance(IntConsumer action) {
+ while (skip > 0) {
+ if (!original.tryAdvance((int ignore) -> { })) {
+ return false;
+ }
+ skip--;
+ }
+ return original.tryAdvance(action);
+ }
+ }
+
+ /**
+ * Int limit spliterator.
+ */
+ private static final class LimitSpliterator extends Spliterators.AbstractIntSpliterator {
+ private final long limit;
+ private final Spliterator.OfInt original;
+ private int position = 0;
+
+ public LimitSpliterator(long limit, Spliterator.OfInt original) {
+ super(
+ original.hasCharacteristics(Spliterator.SIZED)
+ ? Math.min(original.estimateSize(), limit)
+ : Long.MAX_VALUE,
+ original.characteristics());
+ this.limit = limit;
+ this.original = original;
+ }
+
+ @Override
+ public Comparator<? super Integer> getComparator() {
+ return original.getComparator();
+ }
+
+ @Override
+ public boolean tryAdvance(IntConsumer action) {
+ if (position >= limit) {
+ return false;
+ }
+ boolean result = original.tryAdvance(action);
+ position++;
+ return result;
+ }
+ }
+
+ /**
+ * Value holder for various stream operations.
+ */
+ private static final class ValueConsumer implements IntConsumer {
+ int value;
+
+ @Override
+ public void accept(int value) {
+ this.value = value;
+ }
+ }
+
+ private final Spliterator.OfInt spliterator;
+
+ public IntStreamImpl(TerminatableStream<?> previous, Spliterator.OfInt spliterator) {
+ super(previous);
+ this.spliterator = spliterator;
+ }
+
+ // terminals
+ @Override
+ public Spliterator.OfInt spliterator() {
+ terminate();
+ return spliterator;
+ }
+
+ @Override
+ public PrimitiveIterator.OfInt iterator() {
+ return Spliterators.iterator(spliterator());
+ }
+
+ @Override
+ public OptionalInt findFirst() {
+ terminate();
+ ValueConsumer holder = new ValueConsumer();
+ if (spliterator.tryAdvance(holder)) {
+ return OptionalInt.of(holder.value);
+ }
+ return OptionalInt.empty();
+ }
+
+ @Override
+ public OptionalInt findAny() {
+ return findFirst();
+ }
+
+ @Override
+ public boolean noneMatch(IntPredicate predicate) {
+ return !anyMatch(predicate);
+ }
+
+ @Override
+ public boolean allMatch(IntPredicate predicate) {
+ return !anyMatch(predicate.negate());
+ }
+
+ @Override
+ public boolean anyMatch(IntPredicate predicate) {
+ return filter(predicate).findFirst().isPresent();
+ }
+
+ @Override
+ public IntSummaryStatistics summaryStatistics() {
+ return collect(
+ IntSummaryStatistics::new,
+ // TODO switch to a lambda reference once #9340 is fixed
+ (intSummaryStatistics, value) -> intSummaryStatistics.accept(value),
+ IntSummaryStatistics::combine);
+ }
+
+ @Override
+ public OptionalDouble average() {
+ IntSummaryStatistics stats = summaryStatistics();
+ if (stats.getCount() == 0) {
+ return OptionalDouble.empty();
+ }
+ return OptionalDouble.of(stats.getAverage());
+ }
+
+ @Override
+ public long count() {
+ terminate();
+ long count = 0;
+ while (spliterator.tryAdvance((int value) -> { })) {
+ count++;
+ }
+ return count;
+ }
+
+ @Override
+ public OptionalInt max() {
+ IntSummaryStatistics stats = summaryStatistics();
+ if (stats.getCount() == 0) {
+ return OptionalInt.empty();
+ }
+ return OptionalInt.of(stats.getMax());
+ }
+
+ @Override
+ public OptionalInt min() {
+ IntSummaryStatistics stats = summaryStatistics();
+ if (stats.getCount() == 0) {
+ return OptionalInt.empty();
+ }
+ return OptionalInt.of(stats.getMin());
+ }
+
+ @Override
+ public int sum() {
+ return (int) summaryStatistics().getSum();
+ }
+
+ @Override
+ public <R> R collect(
+ Supplier<R> supplier, final ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner) {
+ terminate();
+ final R acc = supplier.get();
+ spliterator.forEachRemaining((int value) -> accumulator.accept(acc, value));
+ return acc;
+ }
+
+ @Override
+ public OptionalInt reduce(IntBinaryOperator op) {
+ ValueConsumer holder = new ValueConsumer();
+ if (spliterator.tryAdvance(holder)) {
+ return OptionalInt.of(reduce(holder.value, op));
+ }
+ terminate();
+ return OptionalInt.empty();
+ }
+
+ @Override
+ public int reduce(int identity, IntBinaryOperator op) {
+ terminate();
+ ValueConsumer holder = new ValueConsumer();
+ holder.value = identity;
+ spliterator.forEachRemaining(
+ (int value) -> {
+ holder.accept(op.applyAsInt(holder.value, value));
+ });
+ return holder.value;
+ }
+
+ @Override
+ public int[] toArray() {
+ terminate();
+ int[] entries = new int[0];
+ // this is legal in js, since the array will be backed by a JS array
+ spliterator.forEachRemaining((int value) -> entries[entries.length] = value);
+
+ return entries;
+ }
+
+ @Override
+ public void forEachOrdered(IntConsumer action) {
+ terminate();
+ spliterator.forEachRemaining(action);
+ }
+
+ @Override
+ public void forEach(IntConsumer action) {
+ forEachOrdered(action);
+ }
+ // end terminals
+
+ // intermediates
+
+ @Override
+ public IntStream filter(IntPredicate predicate) {
+ throwIfTerminated();
+ return new IntStreamImpl(this, new FilterSpliterator(predicate, spliterator));
+ }
+
+ @Override
+ public IntStream map(IntUnaryOperator mapper) {
+ throwIfTerminated();
+ return new IntStreamImpl(this, new MapToIntSpliterator(mapper, spliterator));
+ }
+
+ @Override
+ public <U> Stream<U> mapToObj(IntFunction<? extends U> mapper) {
+ throwIfTerminated();
+ return new StreamImpl<U>(this, new MapToObjSpliterator<U>(mapper, spliterator));
+ }
+
+ @Override
+ public LongStream mapToLong(IntToLongFunction mapper) {
+ throwIfTerminated();
+ return new LongStreamImpl(this, new MapToLongSpliterator(mapper, spliterator));
+ }
+
+ @Override
+ public DoubleStream mapToDouble(IntToDoubleFunction mapper) {
+ throwIfTerminated();
+ return new DoubleStreamImpl(this, new MapToDoubleSpliterator(mapper, spliterator));
+ }
+
+ @Override
+ public IntStream flatMap(IntFunction<? extends IntStream> mapper) {
+ throwIfTerminated();
+ final Spliterator<? extends IntStream> spliteratorOfStreams =
+ new MapToObjSpliterator<>(mapper, spliterator);
+
+ Spliterator.OfInt flatMapSpliterator =
+ new Spliterators.AbstractIntSpliterator(Long.MAX_VALUE, 0) {
+ IntStream nextStream;
+ Spliterator.OfInt next;
+
+ @Override
+ public boolean tryAdvance(IntConsumer action) {
+ // look for a new spliterator
+ while (advanceToNextSpliterator()) {
+ // if we have one, try to read and use it
+ if (next.tryAdvance(action)) {
+ return true;
+ } else {
+ nextStream.close();
+ nextStream = null;
+ // failed, null it out so we can find another
+ next = null;
+ }
+ }
+ return false;
+ }
+
+ private boolean advanceToNextSpliterator() {
+ while (next == null) {
+ if (!spliteratorOfStreams.tryAdvance(
+ n -> {
+ if (n != null) {
+ nextStream = n;
+ next = n.spliterator();
+ }
+ })) {
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+
+ return new IntStreamImpl(this, flatMapSpliterator);
+ }
+
+ @Override
+ public IntStream distinct() {
+ throwIfTerminated();
+ HashSet<Integer> seen = new HashSet<>();
+ return filter(seen::add);
+ }
+
+ @Override
+ public IntStream sorted() {
+ throwIfTerminated();
+
+ AbstractIntSpliterator sortedSpliterator =
+ new Spliterators.AbstractIntSpliterator(
+ spliterator.estimateSize(), spliterator.characteristics() | Spliterator.SORTED) {
+ Spliterator.OfInt ordered = null;
+
+ @Override
+ public Comparator<? super Integer> getComparator() {
+ return null;
+ }
+
+ @Override
+ public boolean tryAdvance(IntConsumer action) {
+ if (ordered == null) {
+ int[] list = new int[0];
+ spliterator.forEachRemaining((int item) -> list[list.length] = item);
+ Arrays.sort(list);
+ ordered = Spliterators.spliterator(list, characteristics());
+ }
+ return ordered.tryAdvance(action);
+ }
+ };
+
+ return new IntStreamImpl(this, sortedSpliterator);
+ }
+
+ @Override
+ public IntStream peek(IntConsumer action) {
+ checkNotNull(action);
+ throwIfTerminated();
+
+ AbstractIntSpliterator peekSpliterator =
+ new Spliterators.AbstractIntSpliterator(
+ spliterator.estimateSize(), spliterator.characteristics()) {
+ @Override
+ public boolean tryAdvance(final IntConsumer innerAction) {
+ return spliterator.tryAdvance(action.andThen(innerAction));
+ }
+ };
+
+ return new IntStreamImpl(this, peekSpliterator);
+ }
+
+ @Override
+ public IntStream limit(long maxSize) {
+ throwIfTerminated();
+ checkState(maxSize >= 0, "maxSize may not be negative");
+ return new IntStreamImpl(this, new LimitSpliterator(maxSize, spliterator));
+ }
+
+ @Override
+ public IntStream skip(long n) {
+ throwIfTerminated();
+ checkState(n >= 0, "n may not be negative");
+ if (n == 0) {
+ return this;
+ }
+ return new IntStreamImpl(this, new SkipSpliterator(n, spliterator));
+ }
+
+ @Override
+ public LongStream asLongStream() {
+ return mapToLong(i -> (long) i);
+ }
+
+ @Override
+ public DoubleStream asDoubleStream() {
+ return mapToDouble(i -> (double) i);
+ }
+
+ @Override
+ public Stream<Integer> boxed() {
+ return mapToObj(Integer::valueOf);
+ }
+
+ @Override
+ public IntStream sequential() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public IntStream parallel() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public boolean isParallel() {
+ throwIfTerminated();
+ return false;
+ }
+
+ @Override
+ public IntStream unordered() {
+ throwIfTerminated();
+ return this;
+ }
+}
diff --git a/user/super/com/google/gwt/emul/java/util/stream/LongStream.java b/user/super/com/google/gwt/emul/java/util/stream/LongStream.java
index 6981225..611ef9b 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/LongStream.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/LongStream.java
@@ -13,15 +13,12 @@
* License for the specific language governing permissions and limitations under
* the License.
*/
-
package java.util.stream;
-import static javaemul.internal.InternalPreconditions.checkNotNull;
import static javaemul.internal.InternalPreconditions.checkState;
import java.util.Arrays;
import java.util.Comparator;
-import java.util.HashSet;
import java.util.LongSummaryStatistics;
import java.util.OptionalDouble;
import java.util.OptionalLong;
@@ -30,9 +27,6 @@
import java.util.Spliterators;
import java.util.Spliterators.AbstractLongSpliterator;
import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-import java.util.function.DoubleConsumer;
-import java.util.function.IntConsumer;
import java.util.function.LongBinaryOperator;
import java.util.function.LongConsumer;
import java.util.function.LongFunction;
@@ -51,18 +45,23 @@
public interface LongStream extends BaseStream<Long, LongStream> {
/**
- * Value holder for various stream operations.
+ * See <a
+ * href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/LongStream.Builder.html">the
+ * official Java API doc</a> for details.
*/
- static final class ValueConsumer implements LongConsumer {
- long value;
-
+ interface Builder extends LongConsumer {
@Override
- public void accept(long value) {
- this.value = value;
+ void accept(long t);
+
+ default LongStream.Builder add(long t) {
+ accept(t);
+ return this;
}
+
+ LongStream build();
}
- static LongStream.Builder builder() {
+ static Builder builder() {
return new Builder() {
private long[] items = new long[0];
@@ -126,7 +125,7 @@
}
};
- LongStream result = new LongStreamSource(null, spliterator);
+ LongStream result = new LongStreamImpl(null, spliterator);
result.onClose(a::close);
result.onClose(b::close);
@@ -135,7 +134,7 @@
}
static LongStream empty() {
- return new EmptyLongStreamSource(null);
+ return new LongStreamImpl.Empty(null);
}
static LongStream generate(LongSupplier s) {
@@ -219,23 +218,6 @@
return StreamSupport.longStream(spliterator, false);
}
- /**
- * See
- * <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/LongStream.Builder.html">
- * the official Java API doc</a> for details.
- */
- public interface Builder extends LongConsumer {
- @Override
- void accept(long t);
-
- default LongStream.Builder add(long t) {
- accept(t);
- return this;
- }
-
- LongStream build();
- }
-
boolean allMatch(LongPredicate predicate);
boolean anyMatch(LongPredicate predicate);
@@ -307,769 +289,4 @@
LongSummaryStatistics summaryStatistics();
long[] toArray();
-
- /**
- * Represents an empty stream, doing nothing for all methods.
- */
- static class EmptyLongStreamSource extends TerminatableStream<EmptyLongStreamSource>
- implements LongStream {
- public EmptyLongStreamSource(TerminatableStream<?> previous) {
- super(previous);
- }
-
- @Override
- public LongStream filter(LongPredicate predicate) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public LongStream map(LongUnaryOperator mapper) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
- throwIfTerminated();
- return new Stream.EmptyStreamSource<U>(this);
- }
-
- @Override
- public IntStream mapToInt(LongToIntFunction mapper) {
- throwIfTerminated();
- return new IntStream.EmptyIntStreamSource(this);
- }
-
- @Override
- public DoubleStream mapToDouble(LongToDoubleFunction mapper) {
- throwIfTerminated();
- return new DoubleStream.EmptyDoubleStreamSource(this);
- }
-
- @Override
- public LongStream flatMap(LongFunction<? extends LongStream> mapper) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public LongStream distinct() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public LongStream sorted() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public LongStream peek(LongConsumer action) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public LongStream limit(long maxSize) {
- throwIfTerminated();
- checkState(maxSize >= 0, "maxSize may not be negative");
- return this;
- }
-
- @Override
- public LongStream skip(long n) {
- throwIfTerminated();
- checkState(n >= 0, "n may not be negative");
- return this;
- }
-
- @Override
- public void forEach(LongConsumer action) {
- terminate();
- }
-
- @Override
- public void forEachOrdered(LongConsumer action) {
- terminate();
- }
-
- @Override
- public long[] toArray() {
- terminate();
- return new long[0];
- }
-
- @Override
- public long reduce(long identity, LongBinaryOperator op) {
- terminate();
- return identity;
- }
-
- @Override
- public OptionalLong reduce(LongBinaryOperator op) {
- terminate();
- return OptionalLong.empty();
- }
-
- @Override
- public <R> R collect(
- Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner) {
- terminate();
- return supplier.get();
- }
-
- @Override
- public long sum() {
- terminate();
- return 0;
- }
-
- @Override
- public OptionalLong min() {
- terminate();
- return OptionalLong.empty();
- }
-
- @Override
- public OptionalLong max() {
- terminate();
- return OptionalLong.empty();
- }
-
- @Override
- public long count() {
- terminate();
- return 0;
- }
-
- @Override
- public OptionalDouble average() {
- terminate();
- return OptionalDouble.empty();
- }
-
- @Override
- public LongSummaryStatistics summaryStatistics() {
- terminate();
- return new LongSummaryStatistics();
- }
-
- @Override
- public boolean anyMatch(LongPredicate predicate) {
- terminate();
- return false;
- }
-
- @Override
- public boolean allMatch(LongPredicate predicate) {
- terminate();
- return true;
- }
-
- @Override
- public boolean noneMatch(LongPredicate predicate) {
- terminate();
- return true;
- }
-
- @Override
- public OptionalLong findFirst() {
- terminate();
- return OptionalLong.empty();
- }
-
- @Override
- public OptionalLong findAny() {
- terminate();
- return OptionalLong.empty();
- }
-
- @Override
- public DoubleStream asDoubleStream() {
- throwIfTerminated();
- return new DoubleStream.EmptyDoubleStreamSource(this);
- }
-
- @Override
- public Stream<Long> boxed() {
- throwIfTerminated();
- return new Stream.EmptyStreamSource<Long>(this);
- }
-
- @Override
- public LongStream sequential() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public LongStream parallel() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public PrimitiveIterator.OfLong iterator() {
- return Spliterators.iterator(spliterator());
- }
-
- @Override
- public Spliterator.OfLong spliterator() {
- terminate();
- return Spliterators.emptyLongSpliterator();
- }
-
- @Override
- public boolean isParallel() {
- throwIfTerminated();
- return false;
- }
-
- @Override
- public LongStream unordered() {
- throwIfTerminated();
- return this;
- }
- }
-
- /**
- * Long to Int map spliterator.
- */
- static final class MapToIntSpliterator extends Spliterators.AbstractIntSpliterator {
- private final LongToIntFunction map;
- private final Spliterator.OfLong original;
-
- public MapToIntSpliterator(LongToIntFunction map, Spliterator.OfLong original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final IntConsumer action) {
- return original.tryAdvance((long u) -> action.accept(map.applyAsInt(u)));
- }
- }
-
- /**
- * Long to Object map spliterator.
- * @param <T> the type of data in the object spliterator
- */
- static final class MapToObjSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
- private final LongFunction<? extends T> map;
- private final Spliterator.OfLong original;
-
- public MapToObjSpliterator(LongFunction<? extends T> map, Spliterator.OfLong original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final Consumer<? super T> action) {
- return original.tryAdvance((long u) -> action.accept(map.apply(u)));
- }
- }
-
- /**
- * Long to Long map spliterator.
- */
- static final class MapToLongSpliterator extends Spliterators.AbstractLongSpliterator {
- private final LongUnaryOperator map;
- private final Spliterator.OfLong original;
-
- public MapToLongSpliterator(LongUnaryOperator map, Spliterator.OfLong original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final LongConsumer action) {
- return original.tryAdvance((long u) -> action.accept(map.applyAsLong(u)));
- }
- }
-
- /**
- * Long to Double map Spliterator.
- */
- static final class MapToDoubleSpliterator extends Spliterators.AbstractDoubleSpliterator {
- private final LongToDoubleFunction map;
- private final Spliterator.OfLong original;
-
- public MapToDoubleSpliterator(LongToDoubleFunction map, Spliterator.OfLong original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final DoubleConsumer action) {
- return original.tryAdvance((long u) -> action.accept(map.applyAsDouble(u)));
- }
- }
-
- /**
- * Long filter spliterator.
- */
- static final class FilterSpliterator extends Spliterators.AbstractLongSpliterator {
- private final LongPredicate filter;
- private final Spliterator.OfLong original;
-
- private boolean found;
-
- public FilterSpliterator(LongPredicate filter, Spliterator.OfLong original) {
- super(original.estimateSize(), original.characteristics() & ~Spliterator.SIZED);
- checkNotNull(filter);
- this.filter = filter;
- this.original = original;
- }
-
- @Override
- public Comparator<? super Long> getComparator() {
- return original.getComparator();
- }
-
- @Override
- public boolean tryAdvance(final LongConsumer action) {
- found = false;
- while (!found
- && original.tryAdvance(
- (long item) -> {
- if (filter.test(item)) {
- found = true;
- action.accept(item);
- }
- })) {
- // do nothing, work is done in tryAdvance
- }
-
- return found;
- }
- }
-
- /**
- * Long skip spliterator.
- */
- static final class SkipSpliterator extends Spliterators.AbstractLongSpliterator {
- private long skip;
- private final Spliterator.OfLong original;
-
- public SkipSpliterator(long skip, Spliterator.OfLong original) {
- super(
- original.hasCharacteristics(Spliterator.SIZED)
- ? Math.max(0, original.estimateSize() - skip)
- : Long.MAX_VALUE,
- original.characteristics());
- this.skip = skip;
- this.original = original;
- }
-
- @Override
- public Comparator<? super Long> getComparator() {
- return original.getComparator();
- }
-
- @Override
- public boolean tryAdvance(LongConsumer action) {
- while (skip > 0) {
- if (!original.tryAdvance((long ignore) -> { })) {
- return false;
- }
- skip--;
- }
- return original.tryAdvance(action);
- }
- }
-
- /**
- * Long limit spliterator.
- */
- static final class LimitSpliterator extends Spliterators.AbstractLongSpliterator {
- private final long limit;
- private final Spliterator.OfLong original;
- private int position = 0;
-
- public LimitSpliterator(long limit, Spliterator.OfLong original) {
- super(
- original.hasCharacteristics(Spliterator.SIZED)
- ? Math.min(original.estimateSize(), limit)
- : Long.MAX_VALUE,
- original.characteristics());
- this.limit = limit;
- this.original = original;
- }
-
- @Override
- public Comparator<? super Long> getComparator() {
- return original.getComparator();
- }
-
- @Override
- public boolean tryAdvance(LongConsumer action) {
- if (position >= limit) {
- return false;
- }
- boolean result = original.tryAdvance(action);
- position++;
- return result;
- }
- }
-
- /**
- * Main implementation of LongStream, wrapping a single spliterator, and an optional parent
- * stream.
- */
- static class LongStreamSource extends TerminatableStream<LongStreamSource> implements LongStream {
- private final Spliterator.OfLong spliterator;
-
- public LongStreamSource(TerminatableStream<?> previous, Spliterator.OfLong spliterator) {
- super(previous);
- this.spliterator = spliterator;
- }
-
- // terminals
-
- @Override
- public void forEach(LongConsumer action) {
- forEachOrdered(action);
- }
-
- @Override
- public void forEachOrdered(LongConsumer action) {
- terminate();
- spliterator.forEachRemaining(action);
- }
-
- @Override
- public long[] toArray() {
- terminate();
- long[] entries = new long[0];
- // this is legal in js, since the array will be backed by a JS array
- spliterator.forEachRemaining((long value) -> entries[entries.length] = value);
-
- return entries;
- }
-
- @Override
- public long reduce(long identity, LongBinaryOperator op) {
- terminate();
- ValueConsumer holder = new ValueConsumer();
- holder.value = identity;
- spliterator.forEachRemaining(
- (long value) -> {
- holder.accept(op.applyAsLong(holder.value, value));
- });
- return holder.value;
- }
-
- @Override
- public OptionalLong reduce(LongBinaryOperator op) {
- ValueConsumer holder = new ValueConsumer();
- if (spliterator.tryAdvance(holder)) {
- return OptionalLong.of(reduce(holder.value, op));
- }
- terminate();
- return OptionalLong.empty();
- }
-
- @Override
- public <R> R collect(
- Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner) {
- terminate();
- final R acc = supplier.get();
- spliterator.forEachRemaining((long value) -> accumulator.accept(acc, value));
- return acc;
- }
-
- @Override
- public long sum() {
- return summaryStatistics().getSum();
- }
-
- @Override
- public OptionalLong min() {
- LongSummaryStatistics stats = summaryStatistics();
- if (stats.getCount() == 0) {
- return OptionalLong.empty();
- }
- return OptionalLong.of(stats.getMin());
- }
-
- @Override
- public OptionalLong max() {
- LongSummaryStatistics stats = summaryStatistics();
- if (stats.getCount() == 0) {
- return OptionalLong.empty();
- }
- return OptionalLong.of(stats.getMax());
- }
-
- @Override
- public long count() {
- terminate();
- long count = 0;
- while (spliterator.tryAdvance((long value) -> { })) {
- count++;
- }
- return count;
- }
-
- @Override
- public OptionalDouble average() {
- LongSummaryStatistics stats = summaryStatistics();
- if (stats.getCount() == 0) {
- return OptionalDouble.empty();
- }
- return OptionalDouble.of(stats.getAverage());
- }
-
- @Override
- public LongSummaryStatistics summaryStatistics() {
- return collect(
- LongSummaryStatistics::new,
- // TODO switch to a lambda reference once #9340 is fixed
- (longSummaryStatistics, value) -> longSummaryStatistics.accept(value),
- LongSummaryStatistics::combine);
- }
-
- @Override
- public boolean anyMatch(LongPredicate predicate) {
- return filter(predicate).findFirst().isPresent();
- }
-
- @Override
- public boolean allMatch(LongPredicate predicate) {
- return !anyMatch(predicate.negate());
- }
-
- @Override
- public boolean noneMatch(LongPredicate predicate) {
- return !anyMatch(predicate);
- }
-
- @Override
- public OptionalLong findFirst() {
- terminate();
- ValueConsumer holder = new ValueConsumer();
- if (spliterator.tryAdvance(holder)) {
- return OptionalLong.of(holder.value);
- }
- return OptionalLong.empty();
- }
-
- @Override
- public OptionalLong findAny() {
- return findFirst();
- }
-
- @Override
- public PrimitiveIterator.OfLong iterator() {
- return Spliterators.iterator(spliterator());
- }
-
- @Override
- public Spliterator.OfLong spliterator() {
- terminate();
- return spliterator;
- }
- // end terminals
-
- // intermediates
- @Override
- public LongStream filter(LongPredicate predicate) {
- throwIfTerminated();
- return new LongStreamSource(this, new FilterSpliterator(predicate, spliterator));
- }
-
- @Override
- public LongStream map(LongUnaryOperator mapper) {
- throwIfTerminated();
- return new LongStream.LongStreamSource(this, new MapToLongSpliterator(mapper, spliterator));
- }
-
- @Override
- public <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
- throwIfTerminated();
- return new Stream.StreamSource<U>(this, new MapToObjSpliterator<U>(mapper, spliterator));
- }
-
- @Override
- public IntStream mapToInt(LongToIntFunction mapper) {
- throwIfTerminated();
- return new IntStream.IntStreamSource(this, new MapToIntSpliterator(mapper, spliterator));
- }
-
- @Override
- public DoubleStream mapToDouble(LongToDoubleFunction mapper) {
- throwIfTerminated();
- return new DoubleStream.DoubleStreamSource(
- this, new MapToDoubleSpliterator(mapper, spliterator));
- }
-
- @Override
- public LongStream flatMap(LongFunction<? extends LongStream> mapper) {
- throwIfTerminated();
- final Spliterator<? extends LongStream> spliteratorOfStreams =
- new MapToObjSpliterator<>(mapper, spliterator);
-
- AbstractLongSpliterator flatMapSpliterator =
- new Spliterators.AbstractLongSpliterator(Long.MAX_VALUE, 0) {
- LongStream nextStream;
- Spliterator.OfLong next;
-
- @Override
- public boolean tryAdvance(LongConsumer action) {
- // look for a new spliterator
- while (advanceToNextSpliterator()) {
- // if we have one, try to read and use it
- if (next.tryAdvance(action)) {
- return true;
- } else {
- nextStream.close();
- nextStream = null;
- // failed, null it out so we can find another
- next = null;
- }
- }
- return false;
- }
-
- private boolean advanceToNextSpliterator() {
- while (next == null) {
- if (!spliteratorOfStreams.tryAdvance(
- n -> {
- if (n != null) {
- nextStream = n;
- next = n.spliterator();
- }
- })) {
- return false;
- }
- }
- return true;
- }
- };
-
- return new LongStreamSource(this, flatMapSpliterator);
- }
-
- @Override
- public LongStream distinct() {
- throwIfTerminated();
- HashSet<Long> seen = new HashSet<>();
- return filter(seen::add);
- }
-
- @Override
- public LongStream sorted() {
- throwIfTerminated();
-
- AbstractLongSpliterator sortedSpliterator =
- new Spliterators.AbstractLongSpliterator(
- spliterator.estimateSize(), spliterator.characteristics() | Spliterator.SORTED) {
- Spliterator.OfLong ordered = null;
-
- @Override
- public Comparator<? super Long> getComparator() {
- return null;
- }
-
- @Override
- public boolean tryAdvance(LongConsumer action) {
- if (ordered == null) {
- long[] list = new long[0];
- spliterator.forEachRemaining((long item) -> list[list.length] = item);
- Arrays.sort(list);
- ordered = Spliterators.spliterator(list, characteristics());
- }
- return ordered.tryAdvance(action);
- }
- };
-
- return new LongStreamSource(this, sortedSpliterator);
- }
-
- @Override
- public LongStream peek(LongConsumer action) {
- checkNotNull(action);
- throwIfTerminated();
-
- AbstractLongSpliterator peekSpliterator =
- new Spliterators.AbstractLongSpliterator(
- spliterator.estimateSize(), spliterator.characteristics()) {
- @Override
- public boolean tryAdvance(final LongConsumer innerAction) {
- return spliterator.tryAdvance(action.andThen(innerAction));
- }
- };
-
- return new LongStreamSource(this, peekSpliterator);
- }
-
- @Override
- public LongStream limit(long maxSize) {
- throwIfTerminated();
- checkState(maxSize >= 0, "maxSize may not be negative");
- return new LongStreamSource(this, new LimitSpliterator(maxSize, spliterator));
- }
-
- @Override
- public LongStream skip(long n) {
- throwIfTerminated();
- checkState(n >= 0, "n may not be negative");
- if (n == 0) {
- return this;
- }
- return new LongStreamSource(this, new SkipSpliterator(n, spliterator));
- }
-
- @Override
- public DoubleStream asDoubleStream() {
- return mapToDouble(x -> (double) x);
- }
-
- @Override
- public Stream<Long> boxed() {
- return mapToObj(Long::valueOf);
- }
-
- @Override
- public LongStream sequential() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public LongStream parallel() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public boolean isParallel() {
- throwIfTerminated();
- return false;
- }
-
- @Override
- public LongStream unordered() {
- throwIfTerminated();
- return this;
- }
- }
}
diff --git a/user/super/com/google/gwt/emul/java/util/stream/LongStreamImpl.java b/user/super/com/google/gwt/emul/java/util/stream/LongStreamImpl.java
new file mode 100644
index 0000000..ee9a379
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/stream/LongStreamImpl.java
@@ -0,0 +1,819 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package java.util.stream;
+
+import static javaemul.internal.InternalPreconditions.checkNotNull;
+import static javaemul.internal.InternalPreconditions.checkState;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LongSummaryStatistics;
+import java.util.OptionalDouble;
+import java.util.OptionalLong;
+import java.util.PrimitiveIterator;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.Spliterators.AbstractLongSpliterator;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.DoubleConsumer;
+import java.util.function.IntConsumer;
+import java.util.function.LongBinaryOperator;
+import java.util.function.LongConsumer;
+import java.util.function.LongFunction;
+import java.util.function.LongPredicate;
+import java.util.function.LongToDoubleFunction;
+import java.util.function.LongToIntFunction;
+import java.util.function.LongUnaryOperator;
+import java.util.function.ObjLongConsumer;
+import java.util.function.Supplier;
+
+/**
+ * Main implementation of LongStream, wrapping a single spliterator, and an optional parent stream.
+ */
+final class LongStreamImpl extends TerminatableStream<LongStreamImpl> implements LongStream {
+
+ /**
+ * Represents an empty stream, doing nothing for all methods.
+ */
+ static class Empty extends TerminatableStream<Empty> implements LongStream {
+ public Empty(TerminatableStream<?> previous) {
+ super(previous);
+ }
+
+ @Override
+ public LongStream filter(LongPredicate predicate) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public LongStream map(LongUnaryOperator mapper) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
+ throwIfTerminated();
+ return new StreamImpl.Empty<U>(this);
+ }
+
+ @Override
+ public IntStream mapToInt(LongToIntFunction mapper) {
+ throwIfTerminated();
+ return new IntStreamImpl.Empty(this);
+ }
+
+ @Override
+ public DoubleStream mapToDouble(LongToDoubleFunction mapper) {
+ throwIfTerminated();
+ return new DoubleStreamImpl.Empty(this);
+ }
+
+ @Override
+ public LongStream flatMap(LongFunction<? extends LongStream> mapper) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public LongStream distinct() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public LongStream sorted() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public LongStream peek(LongConsumer action) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public LongStream limit(long maxSize) {
+ throwIfTerminated();
+ checkState(maxSize >= 0, "maxSize may not be negative");
+ return this;
+ }
+
+ @Override
+ public LongStream skip(long n) {
+ throwIfTerminated();
+ checkState(n >= 0, "n may not be negative");
+ return this;
+ }
+
+ @Override
+ public void forEach(LongConsumer action) {
+ terminate();
+ }
+
+ @Override
+ public void forEachOrdered(LongConsumer action) {
+ terminate();
+ }
+
+ @Override
+ public long[] toArray() {
+ terminate();
+ return new long[0];
+ }
+
+ @Override
+ public long reduce(long identity, LongBinaryOperator op) {
+ terminate();
+ return identity;
+ }
+
+ @Override
+ public OptionalLong reduce(LongBinaryOperator op) {
+ terminate();
+ return OptionalLong.empty();
+ }
+
+ @Override
+ public <R> R collect(
+ Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner) {
+ terminate();
+ return supplier.get();
+ }
+
+ @Override
+ public long sum() {
+ terminate();
+ return 0;
+ }
+
+ @Override
+ public OptionalLong min() {
+ terminate();
+ return OptionalLong.empty();
+ }
+
+ @Override
+ public OptionalLong max() {
+ terminate();
+ return OptionalLong.empty();
+ }
+
+ @Override
+ public long count() {
+ terminate();
+ return 0;
+ }
+
+ @Override
+ public OptionalDouble average() {
+ terminate();
+ return OptionalDouble.empty();
+ }
+
+ @Override
+ public LongSummaryStatistics summaryStatistics() {
+ terminate();
+ return new LongSummaryStatistics();
+ }
+
+ @Override
+ public boolean anyMatch(LongPredicate predicate) {
+ terminate();
+ return false;
+ }
+
+ @Override
+ public boolean allMatch(LongPredicate predicate) {
+ terminate();
+ return true;
+ }
+
+ @Override
+ public boolean noneMatch(LongPredicate predicate) {
+ terminate();
+ return true;
+ }
+
+ @Override
+ public OptionalLong findFirst() {
+ terminate();
+ return OptionalLong.empty();
+ }
+
+ @Override
+ public OptionalLong findAny() {
+ terminate();
+ return OptionalLong.empty();
+ }
+
+ @Override
+ public DoubleStream asDoubleStream() {
+ throwIfTerminated();
+ return new DoubleStreamImpl.Empty(this);
+ }
+
+ @Override
+ public Stream<Long> boxed() {
+ throwIfTerminated();
+ return new StreamImpl.Empty<Long>(this);
+ }
+
+ @Override
+ public LongStream sequential() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public LongStream parallel() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public PrimitiveIterator.OfLong iterator() {
+ return Spliterators.iterator(spliterator());
+ }
+
+ @Override
+ public Spliterator.OfLong spliterator() {
+ terminate();
+ return Spliterators.emptyLongSpliterator();
+ }
+
+ @Override
+ public boolean isParallel() {
+ throwIfTerminated();
+ return false;
+ }
+
+ @Override
+ public LongStream unordered() {
+ throwIfTerminated();
+ return this;
+ }
+ }
+
+ /**
+ * Long to Int map spliterator.
+ */
+ private static final class MapToIntSpliterator extends Spliterators.AbstractIntSpliterator {
+ private final LongToIntFunction map;
+ private final Spliterator.OfLong original;
+
+ public MapToIntSpliterator(LongToIntFunction map, Spliterator.OfLong original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final IntConsumer action) {
+ return original.tryAdvance((long u) -> action.accept(map.applyAsInt(u)));
+ }
+ }
+
+ /**
+ * Long to Object map spliterator.
+ *
+ * @param <T> the type of data in the object spliterator
+ */
+ private static final class MapToObjSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
+ private final LongFunction<? extends T> map;
+ private final Spliterator.OfLong original;
+
+ public MapToObjSpliterator(LongFunction<? extends T> map, Spliterator.OfLong original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final Consumer<? super T> action) {
+ return original.tryAdvance((long u) -> action.accept(map.apply(u)));
+ }
+ }
+
+ /**
+ * Long to Long map spliterator.
+ */
+ private static final class MapToLongSpliterator extends Spliterators.AbstractLongSpliterator {
+ private final LongUnaryOperator map;
+ private final Spliterator.OfLong original;
+
+ public MapToLongSpliterator(LongUnaryOperator map, Spliterator.OfLong original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final LongConsumer action) {
+ return original.tryAdvance((long u) -> action.accept(map.applyAsLong(u)));
+ }
+ }
+
+ /**
+ * Long to Double map Spliterator.
+ */
+ private static final class MapToDoubleSpliterator extends Spliterators.AbstractDoubleSpliterator {
+ private final LongToDoubleFunction map;
+ private final Spliterator.OfLong original;
+
+ public MapToDoubleSpliterator(LongToDoubleFunction map, Spliterator.OfLong original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final DoubleConsumer action) {
+ return original.tryAdvance((long u) -> action.accept(map.applyAsDouble(u)));
+ }
+ }
+
+ /**
+ * Long filter spliterator.
+ */
+ private static final class FilterSpliterator extends Spliterators.AbstractLongSpliterator {
+ private final LongPredicate filter;
+ private final Spliterator.OfLong original;
+
+ private boolean found;
+
+ public FilterSpliterator(LongPredicate filter, Spliterator.OfLong original) {
+ super(original.estimateSize(), original.characteristics() & ~Spliterator.SIZED);
+ checkNotNull(filter);
+ this.filter = filter;
+ this.original = original;
+ }
+
+ @Override
+ public Comparator<? super Long> getComparator() {
+ return original.getComparator();
+ }
+
+ @Override
+ public boolean tryAdvance(final LongConsumer action) {
+ found = false;
+ while (!found
+ && original.tryAdvance(
+ (long item) -> {
+ if (filter.test(item)) {
+ found = true;
+ action.accept(item);
+ }
+ })) {
+ // do nothing, work is done in tryAdvance
+ }
+
+ return found;
+ }
+ }
+
+ /**
+ * Long skip spliterator.
+ */
+ private static final class SkipSpliterator extends Spliterators.AbstractLongSpliterator {
+ private long skip;
+ private final Spliterator.OfLong original;
+
+ public SkipSpliterator(long skip, Spliterator.OfLong original) {
+ super(
+ original.hasCharacteristics(Spliterator.SIZED)
+ ? Math.max(0, original.estimateSize() - skip)
+ : Long.MAX_VALUE,
+ original.characteristics());
+ this.skip = skip;
+ this.original = original;
+ }
+
+ @Override
+ public Comparator<? super Long> getComparator() {
+ return original.getComparator();
+ }
+
+ @Override
+ public boolean tryAdvance(LongConsumer action) {
+ while (skip > 0) {
+ if (!original.tryAdvance((long ignore) -> { })) {
+ return false;
+ }
+ skip--;
+ }
+ return original.tryAdvance(action);
+ }
+ }
+
+ /**
+ * Long limit spliterator.
+ */
+ private static final class LimitSpliterator extends Spliterators.AbstractLongSpliterator {
+ private final long limit;
+ private final Spliterator.OfLong original;
+ private int position = 0;
+
+ public LimitSpliterator(long limit, Spliterator.OfLong original) {
+ super(
+ original.hasCharacteristics(Spliterator.SIZED)
+ ? Math.min(original.estimateSize(), limit)
+ : Long.MAX_VALUE,
+ original.characteristics());
+ this.limit = limit;
+ this.original = original;
+ }
+
+ @Override
+ public Comparator<? super Long> getComparator() {
+ return original.getComparator();
+ }
+
+ @Override
+ public boolean tryAdvance(LongConsumer action) {
+ if (position >= limit) {
+ return false;
+ }
+ boolean result = original.tryAdvance(action);
+ position++;
+ return result;
+ }
+ }
+
+ /**
+ * Value holder for various stream operations.
+ */
+ private static final class ValueConsumer implements LongConsumer {
+ long value;
+
+ @Override
+ public void accept(long value) {
+ this.value = value;
+ }
+ }
+
+ private final Spliterator.OfLong spliterator;
+
+ public LongStreamImpl(TerminatableStream<?> previous, Spliterator.OfLong spliterator) {
+ super(previous);
+ this.spliterator = spliterator;
+ }
+
+ // terminals
+
+ @Override
+ public void forEach(LongConsumer action) {
+ forEachOrdered(action);
+ }
+
+ @Override
+ public void forEachOrdered(LongConsumer action) {
+ terminate();
+ spliterator.forEachRemaining(action);
+ }
+
+ @Override
+ public long[] toArray() {
+ terminate();
+ long[] entries = new long[0];
+ // this is legal in js, since the array will be backed by a JS array
+ spliterator.forEachRemaining((long value) -> entries[entries.length] = value);
+
+ return entries;
+ }
+
+ @Override
+ public long reduce(long identity, LongBinaryOperator op) {
+ terminate();
+ ValueConsumer holder = new ValueConsumer();
+ holder.value = identity;
+ spliterator.forEachRemaining(
+ (long value) -> {
+ holder.accept(op.applyAsLong(holder.value, value));
+ });
+ return holder.value;
+ }
+
+ @Override
+ public OptionalLong reduce(LongBinaryOperator op) {
+ ValueConsumer holder = new ValueConsumer();
+ if (spliterator.tryAdvance(holder)) {
+ return OptionalLong.of(reduce(holder.value, op));
+ }
+ terminate();
+ return OptionalLong.empty();
+ }
+
+ @Override
+ public <R> R collect(
+ Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner) {
+ terminate();
+ final R acc = supplier.get();
+ spliterator.forEachRemaining((long value) -> accumulator.accept(acc, value));
+ return acc;
+ }
+
+ @Override
+ public long sum() {
+ return summaryStatistics().getSum();
+ }
+
+ @Override
+ public OptionalLong min() {
+ LongSummaryStatistics stats = summaryStatistics();
+ if (stats.getCount() == 0) {
+ return OptionalLong.empty();
+ }
+ return OptionalLong.of(stats.getMin());
+ }
+
+ @Override
+ public OptionalLong max() {
+ LongSummaryStatistics stats = summaryStatistics();
+ if (stats.getCount() == 0) {
+ return OptionalLong.empty();
+ }
+ return OptionalLong.of(stats.getMax());
+ }
+
+ @Override
+ public long count() {
+ terminate();
+ long count = 0;
+ while (spliterator.tryAdvance((long value) -> { })) {
+ count++;
+ }
+ return count;
+ }
+
+ @Override
+ public OptionalDouble average() {
+ LongSummaryStatistics stats = summaryStatistics();
+ if (stats.getCount() == 0) {
+ return OptionalDouble.empty();
+ }
+ return OptionalDouble.of(stats.getAverage());
+ }
+
+ @Override
+ public LongSummaryStatistics summaryStatistics() {
+ return collect(
+ LongSummaryStatistics::new,
+ // TODO switch to a lambda reference once #9340 is fixed
+ (longSummaryStatistics, value) -> longSummaryStatistics.accept(value),
+ LongSummaryStatistics::combine);
+ }
+
+ @Override
+ public boolean anyMatch(LongPredicate predicate) {
+ return filter(predicate).findFirst().isPresent();
+ }
+
+ @Override
+ public boolean allMatch(LongPredicate predicate) {
+ return !anyMatch(predicate.negate());
+ }
+
+ @Override
+ public boolean noneMatch(LongPredicate predicate) {
+ return !anyMatch(predicate);
+ }
+
+ @Override
+ public OptionalLong findFirst() {
+ terminate();
+ ValueConsumer holder = new ValueConsumer();
+ if (spliterator.tryAdvance(holder)) {
+ return OptionalLong.of(holder.value);
+ }
+ return OptionalLong.empty();
+ }
+
+ @Override
+ public OptionalLong findAny() {
+ return findFirst();
+ }
+
+ @Override
+ public PrimitiveIterator.OfLong iterator() {
+ return Spliterators.iterator(spliterator());
+ }
+
+ @Override
+ public Spliterator.OfLong spliterator() {
+ terminate();
+ return spliterator;
+ }
+ // end terminals
+
+ // intermediates
+ @Override
+ public LongStream filter(LongPredicate predicate) {
+ throwIfTerminated();
+ return new LongStreamImpl(this, new FilterSpliterator(predicate, spliterator));
+ }
+
+ @Override
+ public LongStream map(LongUnaryOperator mapper) {
+ throwIfTerminated();
+ return new LongStreamImpl(this, new MapToLongSpliterator(mapper, spliterator));
+ }
+
+ @Override
+ public <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
+ throwIfTerminated();
+ return new StreamImpl<U>(this, new MapToObjSpliterator<U>(mapper, spliterator));
+ }
+
+ @Override
+ public IntStream mapToInt(LongToIntFunction mapper) {
+ throwIfTerminated();
+ return new IntStreamImpl(this, new MapToIntSpliterator(mapper, spliterator));
+ }
+
+ @Override
+ public DoubleStream mapToDouble(LongToDoubleFunction mapper) {
+ throwIfTerminated();
+ return new DoubleStreamImpl(this, new MapToDoubleSpliterator(mapper, spliterator));
+ }
+
+ @Override
+ public LongStream flatMap(LongFunction<? extends LongStream> mapper) {
+ throwIfTerminated();
+ final Spliterator<? extends LongStream> spliteratorOfStreams =
+ new MapToObjSpliterator<>(mapper, spliterator);
+
+ AbstractLongSpliterator flatMapSpliterator =
+ new Spliterators.AbstractLongSpliterator(Long.MAX_VALUE, 0) {
+ LongStream nextStream;
+ Spliterator.OfLong next;
+
+ @Override
+ public boolean tryAdvance(LongConsumer action) {
+ // look for a new spliterator
+ while (advanceToNextSpliterator()) {
+ // if we have one, try to read and use it
+ if (next.tryAdvance(action)) {
+ return true;
+ } else {
+ nextStream.close();
+ nextStream = null;
+ // failed, null it out so we can find another
+ next = null;
+ }
+ }
+ return false;
+ }
+
+ private boolean advanceToNextSpliterator() {
+ while (next == null) {
+ if (!spliteratorOfStreams.tryAdvance(
+ n -> {
+ if (n != null) {
+ nextStream = n;
+ next = n.spliterator();
+ }
+ })) {
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+
+ return new LongStreamImpl(this, flatMapSpliterator);
+ }
+
+ @Override
+ public LongStream distinct() {
+ throwIfTerminated();
+ HashSet<Long> seen = new HashSet<>();
+ return filter(seen::add);
+ }
+
+ @Override
+ public LongStream sorted() {
+ throwIfTerminated();
+
+ AbstractLongSpliterator sortedSpliterator =
+ new Spliterators.AbstractLongSpliterator(
+ spliterator.estimateSize(), spliterator.characteristics() | Spliterator.SORTED) {
+ Spliterator.OfLong ordered = null;
+
+ @Override
+ public Comparator<? super Long> getComparator() {
+ return null;
+ }
+
+ @Override
+ public boolean tryAdvance(LongConsumer action) {
+ if (ordered == null) {
+ long[] list = new long[0];
+ spliterator.forEachRemaining((long item) -> list[list.length] = item);
+ Arrays.sort(list);
+ ordered = Spliterators.spliterator(list, characteristics());
+ }
+ return ordered.tryAdvance(action);
+ }
+ };
+
+ return new LongStreamImpl(this, sortedSpliterator);
+ }
+
+ @Override
+ public LongStream peek(LongConsumer action) {
+ checkNotNull(action);
+ throwIfTerminated();
+
+ AbstractLongSpliterator peekSpliterator =
+ new Spliterators.AbstractLongSpliterator(
+ spliterator.estimateSize(), spliterator.characteristics()) {
+ @Override
+ public boolean tryAdvance(final LongConsumer innerAction) {
+ return spliterator.tryAdvance(action.andThen(innerAction));
+ }
+ };
+
+ return new LongStreamImpl(this, peekSpliterator);
+ }
+
+ @Override
+ public LongStream limit(long maxSize) {
+ throwIfTerminated();
+ checkState(maxSize >= 0, "maxSize may not be negative");
+ return new LongStreamImpl(this, new LimitSpliterator(maxSize, spliterator));
+ }
+
+ @Override
+ public LongStream skip(long n) {
+ throwIfTerminated();
+ checkState(n >= 0, "n may not be negative");
+ if (n == 0) {
+ return this;
+ }
+ return new LongStreamImpl(this, new SkipSpliterator(n, spliterator));
+ }
+
+ @Override
+ public DoubleStream asDoubleStream() {
+ return mapToDouble(x -> (double) x);
+ }
+
+ @Override
+ public Stream<Long> boxed() {
+ return mapToObj(Long::valueOf);
+ }
+
+ @Override
+ public LongStream sequential() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public LongStream parallel() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public boolean isParallel() {
+ throwIfTerminated();
+ return false;
+ }
+
+ @Override
+ public LongStream unordered() {
+ throwIfTerminated();
+ return this;
+ }
+}
diff --git a/user/super/com/google/gwt/emul/java/util/stream/Stream.java b/user/super/com/google/gwt/emul/java/util/stream/Stream.java
index a313f4a..a963279 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/Stream.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/Stream.java
@@ -13,35 +13,23 @@
* License for the specific language governing permissions and limitations under
* the License.
*/
-
package java.util.stream;
-import static javaemul.internal.InternalPreconditions.checkNotNull;
import static javaemul.internal.InternalPreconditions.checkState;
-import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
import java.util.Optional;
import java.util.Spliterator;
import java.util.Spliterators;
-import java.util.Spliterators.AbstractDoubleSpliterator;
-import java.util.Spliterators.AbstractIntSpliterator;
-import java.util.Spliterators.AbstractLongSpliterator;
import java.util.Spliterators.AbstractSpliterator;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
-import java.util.function.DoubleConsumer;
import java.util.function.Function;
-import java.util.function.IntConsumer;
import java.util.function.IntFunction;
-import java.util.function.LongConsumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.ToDoubleFunction;
@@ -56,16 +44,21 @@
* @param <T> the type of data being streamed
*/
public interface Stream<T> extends BaseStream<T, Stream<T>> {
- /**
- * Value holder for various stream operations.
- */
- static final class ValueConsumer<T> implements Consumer<T> {
- T value;
+ /**
+ * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.Builder.html">
+ * the official Java API doc</a> for details.
+ */
+ interface Builder<T> extends Consumer<T> {
@Override
- public void accept(T value) {
- this.value = value;
+ void accept(T t);
+
+ default Stream.Builder<T> add(T t) {
+ accept(t);
+ return this;
}
+
+ Stream<T> build();
}
static <T> Stream.Builder<T> builder() {
@@ -134,7 +127,7 @@
}
};
- Stream<T> result = new StreamSource<T>(null, spliterator);
+ Stream<T> result = new StreamImpl<T>(null, spliterator);
result.onClose(a::close);
result.onClose(b::close);
@@ -143,7 +136,7 @@
}
static <T> Stream<T> empty() {
- return new EmptyStreamSource<T>(null);
+ return new StreamImpl.Empty<T>(null);
}
static <T> Stream<T> generate(Supplier<T> s) {
@@ -185,22 +178,6 @@
return Arrays.stream(values);
}
- /**
- * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.Builder.html">
- * the official Java API doc</a> for details.
- */
- public interface Builder<T> extends Consumer<T> {
- @Override
- void accept(T t);
-
- default Stream.Builder<T> add(T t) {
- accept(t);
- return this;
- }
-
- Stream<T> build();
- }
-
boolean allMatch(Predicate<? super T> predicate);
boolean anyMatch(Predicate<? super T> predicate);
@@ -265,930 +242,4 @@
Object[] toArray();
<A> A[] toArray(IntFunction<A[]> generator);
-
- /**
- * Represents an empty stream, doing nothing for all methods.
- */
- static class EmptyStreamSource<T> extends TerminatableStream<EmptyStreamSource<T>>
- implements Stream<T> {
-
- public EmptyStreamSource(TerminatableStream<?> previous) {
- super(previous);
- }
-
- @Override
- public Stream<T> filter(Predicate<? super T> predicate) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
- throwIfTerminated();
- return (Stream) this;
- }
-
- @Override
- public IntStream mapToInt(ToIntFunction<? super T> mapper) {
- throwIfTerminated();
- return new IntStream.EmptyIntStreamSource(this);
- }
-
- @Override
- public LongStream mapToLong(ToLongFunction<? super T> mapper) {
- throwIfTerminated();
- return new LongStream.EmptyLongStreamSource(this);
- }
-
- @Override
- public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
- throwIfTerminated();
- return new DoubleStream.EmptyDoubleStreamSource(this);
- }
-
- @Override
- public <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {
- throwIfTerminated();
- return (Stream) this;
- }
-
- @Override
- public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
- throwIfTerminated();
- return new IntStream.EmptyIntStreamSource(this);
- }
-
- @Override
- public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
- throwIfTerminated();
- return new LongStream.EmptyLongStreamSource(this);
- }
-
- @Override
- public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
- throwIfTerminated();
- return new DoubleStream.EmptyDoubleStreamSource(this);
- }
-
- @Override
- public Stream<T> distinct() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public Stream<T> sorted() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public Stream<T> sorted(Comparator<? super T> comparator) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public Stream<T> peek(Consumer<? super T> action) {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public Stream<T> limit(long maxSize) {
- throwIfTerminated();
- checkState(maxSize >= 0, "maxSize may not be negative");
- return this;
- }
-
- @Override
- public Stream<T> skip(long n) {
- throwIfTerminated();
- checkState(n >= 0, "n may not be negative");
- return this;
- }
-
- @Override
- public void forEach(Consumer<? super T> action) {
- terminate();
- // nothing to do
- }
-
- @Override
- public void forEachOrdered(Consumer<? super T> action) {
- terminate();
- // nothing to do
- }
-
- @Override
- public Object[] toArray() {
- terminate();
- return new Object[0];
- }
-
- @Override
- public <A> A[] toArray(IntFunction<A[]> generator) {
- terminate();
- return generator.apply(0);
- }
-
- @Override
- public T reduce(T identity, BinaryOperator<T> accumulator) {
- terminate();
- return identity;
- }
-
- @Override
- public Optional<T> reduce(BinaryOperator<T> accumulator) {
- terminate();
- return Optional.empty();
- }
-
- @Override
- public <U> U reduce(
- U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
- terminate();
- return identity;
- }
-
- @Override
- public <R> R collect(
- Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
- terminate();
- return supplier.get();
- }
-
- @Override
- public <R, A> R collect(Collector<? super T, A, R> collector) {
- terminate();
- return collector.finisher().apply(collector.supplier().get());
- }
-
- @Override
- public Optional<T> min(Comparator<? super T> comparator) {
- terminate();
- return Optional.empty();
- }
-
- @Override
- public Optional<T> max(Comparator<? super T> comparator) {
- terminate();
- return Optional.empty();
- }
-
- @Override
- public long count() {
- terminate();
- return 0;
- }
-
- @Override
- public boolean anyMatch(Predicate<? super T> predicate) {
- terminate();
- return false;
- }
-
- @Override
- public boolean allMatch(Predicate<? super T> predicate) {
- terminate();
- return true;
- }
-
- @Override
- public boolean noneMatch(Predicate<? super T> predicate) {
- terminate();
- return true;
- }
-
- @Override
- public Optional<T> findFirst() {
- terminate();
- return Optional.empty();
- }
-
- @Override
- public Optional<T> findAny() {
- terminate();
- return Optional.empty();
- }
-
- @Override
- public Iterator<T> iterator() {
- terminate();
- return Collections.emptyIterator();
- }
-
- @Override
- public Spliterator<T> spliterator() {
- terminate();
- return Spliterators.emptySpliterator();
- }
-
- @Override
- public boolean isParallel() {
- throwIfTerminated();
- return false;
- }
-
- @Override
- public Stream<T> sequential() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public Stream<T> parallel() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public Stream<T> unordered() {
- throwIfTerminated();
- return this;
- }
- }
-
- /**
- * Object to Object map spliterator.
- * @param <U> the input type
- * @param <T> the output type
- */
- static final class MapToObjSpliterator<U, T> extends Spliterators.AbstractSpliterator<T> {
- private final Function<? super U, ? extends T> map;
- private final Spliterator<U> original;
-
- public MapToObjSpliterator(Function<? super U, ? extends T> map, Spliterator<U> original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final Consumer<? super T> action) {
- return original.tryAdvance(u -> action.accept(map.apply(u)));
- }
- }
-
- /**
- * Object to Int map spliterator.
- * @param <T> the input type
- */
- static final class MapToIntSpliterator<T> extends Spliterators.AbstractIntSpliterator {
- private final ToIntFunction<? super T> map;
- private final Spliterator<T> original;
-
- public MapToIntSpliterator(ToIntFunction<? super T> map, Spliterator<T> original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final IntConsumer action) {
- return original.tryAdvance(u -> action.accept(map.applyAsInt(u)));
- }
- }
-
- /**
- * Object to Long map spliterator.
- * @param <T> the input type
- */
- static final class MapToLongSpliterator<T> extends Spliterators.AbstractLongSpliterator {
- private final ToLongFunction<? super T> map;
- private final Spliterator<T> original;
-
- public MapToLongSpliterator(ToLongFunction<? super T> map, Spliterator<T> original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final LongConsumer action) {
- return original.tryAdvance(u -> action.accept(map.applyAsLong(u)));
- }
- }
-
- /**
- * Object to Double map spliterator.
- * @param <T> the input type
- */
- static final class MapToDoubleSpliterator<T> extends Spliterators.AbstractDoubleSpliterator {
- private final ToDoubleFunction<? super T> map;
- private final Spliterator<T> original;
-
- public MapToDoubleSpliterator(ToDoubleFunction<? super T> map, Spliterator<T> original) {
- super(
- original.estimateSize(),
- original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
- checkNotNull(map);
- this.map = map;
- this.original = original;
- }
-
- @Override
- public boolean tryAdvance(final DoubleConsumer action) {
- return original.tryAdvance(u -> action.accept(map.applyAsDouble(u)));
- }
- }
-
- /**
- * Object filter spliterator.
- * @param <T> the type of data to iterate over
- */
- static final class FilterSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
- private final Predicate<? super T> filter;
- private final Spliterator<T> original;
-
- private boolean found;
-
- public FilterSpliterator(Predicate<? super T> filter, Spliterator<T> original) {
- super(original.estimateSize(), original.characteristics() & ~Spliterator.SIZED);
- checkNotNull(filter);
- this.filter = filter;
- this.original = original;
- }
-
- @Override
- public Comparator<? super T> getComparator() {
- return original.getComparator();
- }
-
- @Override
- public boolean tryAdvance(final Consumer<? super T> action) {
- found = false;
- while (!found
- && original.tryAdvance(
- item -> {
- if (filter.test(item)) {
- found = true;
- action.accept(item);
- }
- })) {
- // do nothing, work is done in tryAdvance
- }
-
- return found;
- }
- }
-
- /**
- * Object skip spliterator.
- * @param <T> the type of data to iterate over
- */
- static final class SkipSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
- private long skip;
- private final Spliterator<T> original;
-
- public SkipSpliterator(long skip, Spliterator<T> original) {
- super(
- original.hasCharacteristics(Spliterator.SIZED)
- ? Math.max(0, original.estimateSize() - skip)
- : Long.MAX_VALUE,
- original.characteristics());
- this.skip = skip;
- this.original = original;
- }
-
- @Override
- public Comparator<? super T> getComparator() {
- return original.getComparator();
- }
-
- @Override
- public boolean tryAdvance(Consumer<? super T> action) {
- while (skip > 0) {
- if (!original.tryAdvance(ignore -> { })) {
- return false;
- }
- skip--;
- }
- return original.tryAdvance(action);
- }
- }
-
- /**
- * Object limit spliterator.
- * @param <T> the type of data to iterate over
- */
- static final class LimitSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
- private final long limit;
- private final Spliterator<T> original;
- private int position = 0;
-
- public LimitSpliterator(long limit, Spliterator<T> original) {
- super(
- original.hasCharacteristics(Spliterator.SIZED)
- ? Math.min(original.estimateSize(), limit)
- : Long.MAX_VALUE,
- original.characteristics());
- this.limit = limit;
- this.original = original;
- }
-
- @Override
- public Comparator<? super T> getComparator() {
- return original.getComparator();
- }
-
- @Override
- public boolean tryAdvance(Consumer<? super T> action) {
- if (position >= limit) {
- return false;
- }
- boolean result = original.tryAdvance(action);
- position++;
- return result;
- }
- }
-
- /**
- * Main implementation of Stream, wrapping a single spliterator and an optional parent stream.
- * @param <T>
- */
- static class StreamSource<T> extends TerminatableStream<StreamSource<T>> implements Stream<T> {
- private final Spliterator<T> spliterator;
-
- public StreamSource(TerminatableStream<?> prev, Spliterator<T> spliterator) {
- super(prev);
- this.spliterator = spliterator;
- }
-
- // terminal
- @Override
- public Spliterator<T> spliterator() {
- terminate();
- return spliterator;
- }
-
- @Override
- public Iterator<T> iterator() {
- return Spliterators.iterator(spliterator());
- }
-
- @Override
- public long count() {
- terminate();
- long count = 0;
- while (spliterator.tryAdvance(a -> { })) {
- count++;
- }
- return count;
- }
-
- @Override
- public void forEach(Consumer<? super T> action) {
- forEachOrdered(action);
- }
-
- @Override
- public void forEachOrdered(Consumer<? super T> action) {
- terminate();
- spliterator.forEachRemaining(action);
- }
-
- @Override
- public Object[] toArray() {
- return toArray(Object[]::new);
- }
-
- @Override
- public <A> A[] toArray(IntFunction<A[]> generator) {
- List<T> collected = collect(Collectors.toList());
- return collected.toArray(generator.apply(collected.size()));
- }
-
- @Override
- public <R> R collect(
- Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
- return collect(
- Collector.of(
- supplier,
- accumulator,
- (a, b) -> {
- combiner.accept(a, b);
- return a;
- }));
- }
-
- @Override
- public <R, A> R collect(final Collector<? super T, A, R> collector) {
- return collector
- .finisher()
- .apply(
- reduce(
- collector.supplier().get(),
- (a, t) -> {
- collector.accumulator().accept(a, t);
- return a;
- },
- collector.combiner()));
- }
-
- @Override
- public Optional<T> findFirst() {
- terminate();
- ValueConsumer<T> holder = new ValueConsumer<T>();
- if (spliterator.tryAdvance(holder)) {
- return Optional.of(holder.value);
- }
- return Optional.empty();
- }
-
- @Override
- public Optional<T> findAny() {
- return findFirst();
- }
-
- @Override
- public boolean anyMatch(Predicate<? super T> predicate) {
- return filter(predicate).findFirst().isPresent();
- }
-
- @Override
- public boolean allMatch(final Predicate<? super T> predicate) {
- return !anyMatch(predicate.negate());
- }
-
- @Override
- public boolean noneMatch(final Predicate<? super T> predicate) {
- return !anyMatch(predicate);
- }
-
- @Override
- public Optional<T> min(final Comparator<? super T> comparator) {
- return reduce(BinaryOperator.minBy(comparator));
- }
-
- @Override
- public Optional<T> max(final Comparator<? super T> comparator) {
- return reduce(BinaryOperator.maxBy(comparator));
- }
-
- @Override
- public T reduce(T identity, BinaryOperator<T> accumulator) {
- return reduce(identity, accumulator, accumulator);
- }
-
- @Override
- public Optional<T> reduce(BinaryOperator<T> accumulator) {
- ValueConsumer<T> consumer = new ValueConsumer<T>();
- if (!spliterator.tryAdvance(consumer)) {
- terminate();
- return Optional.empty();
- }
- return Optional.of(reduce(consumer.value, accumulator));
- }
-
- // combiner is ignored, since we don't parallelize
- @Override
- public <U> U reduce(
- U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
- terminate();
- final ValueConsumer<U> consumer = new ValueConsumer<U>();
- consumer.value = identity;
- spliterator.forEachRemaining(
- item -> {
- consumer.accept(accumulator.apply(consumer.value, item));
- });
- return consumer.value;
- }
- // end terminal
-
- // intermediate
- @Override
- public Stream<T> filter(Predicate<? super T> predicate) {
- throwIfTerminated();
- return new StreamSource<>(this, new FilterSpliterator<>(predicate, spliterator));
- }
-
- @Override
- public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
- throwIfTerminated();
- return new StreamSource<>(this, new MapToObjSpliterator<>(mapper, spliterator));
- }
-
- @Override
- public IntStream mapToInt(ToIntFunction<? super T> mapper) {
- throwIfTerminated();
- return new IntStream.IntStreamSource(this, new MapToIntSpliterator<>(mapper, spliterator));
- }
-
- @Override
- public LongStream mapToLong(ToLongFunction<? super T> mapper) {
- throwIfTerminated();
- return new LongStream.LongStreamSource(this, new MapToLongSpliterator<>(mapper, spliterator));
- }
-
- @Override
- public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
- throwIfTerminated();
- return new DoubleStream.DoubleStreamSource(
- this, new MapToDoubleSpliterator<>(mapper, spliterator));
- }
-
- @Override
- public <R> Stream<R> flatMap(final Function<? super T, ? extends Stream<? extends R>> mapper) {
- throwIfTerminated();
- final Spliterator<? extends Stream<? extends R>> spliteratorOfStreams =
- new MapToObjSpliterator<>(mapper, spliterator);
-
- AbstractSpliterator<R> flatMapSpliterator =
- new Spliterators.AbstractSpliterator<R>(Long.MAX_VALUE, 0) {
- Stream<? extends R> nextStream;
- Spliterator<? extends R> next;
-
- @Override
- public boolean tryAdvance(Consumer<? super R> action) {
- // look for a new spliterator
- while (advanceToNextSpliterator()) {
- // if we have one, try to read and use it
- if (next.tryAdvance(action)) {
- return true;
- } else {
- nextStream.close();
- nextStream = null;
- // failed, null it out so we can find another
- next = null;
- }
- }
- return false;
- }
-
- private boolean advanceToNextSpliterator() {
- while (next == null) {
- if (!spliteratorOfStreams.tryAdvance(
- n -> {
- if (n != null) {
- nextStream = n;
- next = n.spliterator();
- }
- })) {
- return false;
- }
- }
- return true;
- }
- };
-
- return new StreamSource<R>(this, flatMapSpliterator);
- }
-
- @Override
- public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
- throwIfTerminated();
- final Spliterator<? extends IntStream> spliteratorOfStreams =
- new MapToObjSpliterator<>(mapper, spliterator);
-
- AbstractIntSpliterator flatMapSpliterator =
- new Spliterators.AbstractIntSpliterator(Long.MAX_VALUE, 0) {
- IntStream nextStream;
- Spliterator.OfInt next;
-
- @Override
- public boolean tryAdvance(IntConsumer action) {
- // look for a new spliterator
- while (advanceToNextSpliterator()) {
- // if we have one, try to read and use it
- if (next.tryAdvance(action)) {
- return true;
- } else {
- nextStream.close();
- nextStream = null;
- // failed, null it out so we can find another
- next = null;
- }
- }
- return false;
- }
-
- private boolean advanceToNextSpliterator() {
- while (next == null) {
- if (!spliteratorOfStreams.tryAdvance(
- n -> {
- if (n != null) {
- nextStream = n;
- next = n.spliterator();
- }
- })) {
- return false;
- }
- }
- return true;
- }
- };
-
- return new IntStream.IntStreamSource(this, flatMapSpliterator);
- }
-
- @Override
- public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
- throwIfTerminated();
- final Spliterator<? extends LongStream> spliteratorOfStreams =
- new MapToObjSpliterator<>(mapper, spliterator);
-
- AbstractLongSpliterator flatMapSpliterator =
- new Spliterators.AbstractLongSpliterator(Long.MAX_VALUE, 0) {
- LongStream nextStream;
- Spliterator.OfLong next;
-
- @Override
- public boolean tryAdvance(LongConsumer action) {
- // look for a new spliterator
- while (advanceToNextSpliterator()) {
- // if we have one, try to read and use it
- if (next.tryAdvance(action)) {
- return true;
- } else {
- nextStream.close();
- nextStream = null;
- // failed, null it out so we can find another
- next = null;
- }
- }
- return false;
- }
-
- private boolean advanceToNextSpliterator() {
- while (next == null) {
- if (!spliteratorOfStreams.tryAdvance(
- n -> {
- if (n != null) {
- nextStream = n;
- next = n.spliterator();
- }
- })) {
- return false;
- }
- }
- return true;
- }
- };
-
- return new LongStream.LongStreamSource(this, flatMapSpliterator);
- }
-
- @Override
- public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
- throwIfTerminated();
- final Spliterator<? extends DoubleStream> spliteratorOfStreams =
- new MapToObjSpliterator<>(mapper, spliterator);
-
- AbstractDoubleSpliterator flatMapSpliterator =
- new Spliterators.AbstractDoubleSpliterator(Long.MAX_VALUE, 0) {
- DoubleStream nextStream;
- Spliterator.OfDouble next;
-
- @Override
- public boolean tryAdvance(DoubleConsumer action) {
- // look for a new spliterator
- while (advanceToNextSpliterator()) {
- // if we have one, try to read and use it
- if (next.tryAdvance(action)) {
- return true;
- } else {
- nextStream.close();
- nextStream = null;
- // failed, null it out so we can find another
- next = null;
- }
- }
- return false;
- }
-
- private boolean advanceToNextSpliterator() {
- while (next == null) {
- if (!spliteratorOfStreams.tryAdvance(
- n -> {
- if (n != null) {
- nextStream = n;
- next = n.spliterator();
- }
- })) {
- return false;
- }
- }
- return true;
- }
- };
-
- return new DoubleStream.DoubleStreamSource(this, flatMapSpliterator);
- }
-
- @Override
- public Stream<T> distinct() {
- throwIfTerminated();
- HashSet<T> seen = new HashSet<>();
- return filter(seen::add);
- }
-
- @Override
- public Stream<T> sorted() {
- throwIfTerminated();
- Comparator<T> c = (Comparator) Comparator.naturalOrder();
- return sorted(c);
- }
-
- @Override
- public Stream<T> sorted(final Comparator<? super T> comparator) {
- throwIfTerminated();
-
- AbstractSpliterator<T> sortedSpliterator =
- new Spliterators.AbstractSpliterator<T>(
- spliterator.estimateSize(), spliterator.characteristics() | Spliterator.SORTED) {
- Spliterator<T> ordered = null;
-
- @Override
- public Comparator<? super T> getComparator() {
- return comparator == Comparator.naturalOrder() ? null : comparator;
- }
-
- @Override
- public boolean tryAdvance(Consumer<? super T> action) {
- if (ordered == null) {
- List<T> list = new ArrayList<>();
- spliterator.forEachRemaining(list::add);
- Collections.sort(list, comparator);
- ordered = list.spliterator();
- }
- return ordered.tryAdvance(action);
- }
- };
-
- return new StreamSource<>(this, sortedSpliterator);
- }
-
- @Override
- public Stream<T> peek(final Consumer<? super T> action) {
- checkNotNull(action);
- throwIfTerminated();
-
- AbstractSpliterator<T> peekSpliterator =
- new Spliterators.AbstractSpliterator<T>(
- spliterator.estimateSize(), spliterator.characteristics()) {
- @Override
- public boolean tryAdvance(final Consumer<? super T> innerAction) {
- return spliterator.tryAdvance(
- item -> {
- action.accept(item);
- innerAction.accept(item);
- });
- }
- };
-
- return new StreamSource<>(this, peekSpliterator);
- }
-
- @Override
- public Stream<T> limit(long maxSize) {
- throwIfTerminated();
- checkState(maxSize >= 0, "maxSize may not be negative");
- return new StreamSource<>(this, new LimitSpliterator<>(maxSize, spliterator));
- }
-
- @Override
- public Stream<T> skip(long n) {
- throwIfTerminated();
- checkState(n >= 0, "n may not be negative");
- if (n == 0) {
- return this;
- }
- return new StreamSource<>(this, new SkipSpliterator<>(n, spliterator));
- }
-
- @Override
- public boolean isParallel() {
- throwIfTerminated();
- return false;
- }
-
- @Override
- public Stream<T> sequential() {
- throwIfTerminated();
- return this;
- }
-
- @Override
- public Stream<T> parallel() {
- throwIfTerminated();
- // do nothing, no such thing as gwt+parallel
- return this;
- }
-
- @Override
- public Stream<T> unordered() {
- throwIfTerminated();
- return this;
- }
- }
}
diff --git a/user/super/com/google/gwt/emul/java/util/stream/StreamImpl.java b/user/super/com/google/gwt/emul/java/util/stream/StreamImpl.java
new file mode 100644
index 0000000..bb5bc94
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/stream/StreamImpl.java
@@ -0,0 +1,991 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package java.util.stream;
+
+import static javaemul.internal.InternalPreconditions.checkNotNull;
+import static javaemul.internal.InternalPreconditions.checkState;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.Spliterators.AbstractDoubleSpliterator;
+import java.util.Spliterators.AbstractIntSpliterator;
+import java.util.Spliterators.AbstractLongSpliterator;
+import java.util.Spliterators.AbstractSpliterator;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
+import java.util.function.DoubleConsumer;
+import java.util.function.Function;
+import java.util.function.IntConsumer;
+import java.util.function.IntFunction;
+import java.util.function.LongConsumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToIntFunction;
+import java.util.function.ToLongFunction;
+
+/**
+ * Main implementation of Stream, wrapping a single spliterator and an optional parent stream.
+ */
+final class StreamImpl<T> extends TerminatableStream<StreamImpl<T>> implements Stream<T> {
+
+ /**
+ * Represents an empty stream, doing nothing for all methods.
+ */
+ static class Empty<T> extends TerminatableStream<Empty<T>> implements Stream<T> {
+
+ public Empty(TerminatableStream<?> previous) {
+ super(previous);
+ }
+
+ @Override
+ public Stream<T> filter(Predicate<? super T> predicate) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
+ throwIfTerminated();
+ return (Stream) this;
+ }
+
+ @Override
+ public IntStream mapToInt(ToIntFunction<? super T> mapper) {
+ throwIfTerminated();
+ return new IntStreamImpl.Empty(this);
+ }
+
+ @Override
+ public LongStream mapToLong(ToLongFunction<? super T> mapper) {
+ throwIfTerminated();
+ return new LongStreamImpl.Empty(this);
+ }
+
+ @Override
+ public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
+ throwIfTerminated();
+ return new DoubleStreamImpl.Empty(this);
+ }
+
+ @Override
+ public <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {
+ throwIfTerminated();
+ return (Stream) this;
+ }
+
+ @Override
+ public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
+ throwIfTerminated();
+ return new IntStreamImpl.Empty(this);
+ }
+
+ @Override
+ public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
+ throwIfTerminated();
+ return new LongStreamImpl.Empty(this);
+ }
+
+ @Override
+ public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
+ throwIfTerminated();
+ return new DoubleStreamImpl.Empty(this);
+ }
+
+ @Override
+ public Stream<T> distinct() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public Stream<T> sorted() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public Stream<T> sorted(Comparator<? super T> comparator) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public Stream<T> peek(Consumer<? super T> action) {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public Stream<T> limit(long maxSize) {
+ throwIfTerminated();
+ checkState(maxSize >= 0, "maxSize may not be negative");
+ return this;
+ }
+
+ @Override
+ public Stream<T> skip(long n) {
+ throwIfTerminated();
+ checkState(n >= 0, "n may not be negative");
+ return this;
+ }
+
+ @Override
+ public void forEach(Consumer<? super T> action) {
+ terminate();
+ // nothing to do
+ }
+
+ @Override
+ public void forEachOrdered(Consumer<? super T> action) {
+ terminate();
+ // nothing to do
+ }
+
+ @Override
+ public Object[] toArray() {
+ terminate();
+ return new Object[0];
+ }
+
+ @Override
+ public <A> A[] toArray(IntFunction<A[]> generator) {
+ terminate();
+ return generator.apply(0);
+ }
+
+ @Override
+ public T reduce(T identity, BinaryOperator<T> accumulator) {
+ terminate();
+ return identity;
+ }
+
+ @Override
+ public Optional<T> reduce(BinaryOperator<T> accumulator) {
+ terminate();
+ return Optional.empty();
+ }
+
+ @Override
+ public <U> U reduce(
+ U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
+ terminate();
+ return identity;
+ }
+
+ @Override
+ public <R> R collect(
+ Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
+ terminate();
+ return supplier.get();
+ }
+
+ @Override
+ public <R, A> R collect(Collector<? super T, A, R> collector) {
+ terminate();
+ return collector.finisher().apply(collector.supplier().get());
+ }
+
+ @Override
+ public Optional<T> min(Comparator<? super T> comparator) {
+ terminate();
+ return Optional.empty();
+ }
+
+ @Override
+ public Optional<T> max(Comparator<? super T> comparator) {
+ terminate();
+ return Optional.empty();
+ }
+
+ @Override
+ public long count() {
+ terminate();
+ return 0;
+ }
+
+ @Override
+ public boolean anyMatch(Predicate<? super T> predicate) {
+ terminate();
+ return false;
+ }
+
+ @Override
+ public boolean allMatch(Predicate<? super T> predicate) {
+ terminate();
+ return true;
+ }
+
+ @Override
+ public boolean noneMatch(Predicate<? super T> predicate) {
+ terminate();
+ return true;
+ }
+
+ @Override
+ public Optional<T> findFirst() {
+ terminate();
+ return Optional.empty();
+ }
+
+ @Override
+ public Optional<T> findAny() {
+ terminate();
+ return Optional.empty();
+ }
+
+ @Override
+ public Iterator<T> iterator() {
+ terminate();
+ return Collections.emptyIterator();
+ }
+
+ @Override
+ public Spliterator<T> spliterator() {
+ terminate();
+ return Spliterators.emptySpliterator();
+ }
+
+ @Override
+ public boolean isParallel() {
+ throwIfTerminated();
+ return false;
+ }
+
+ @Override
+ public Stream<T> sequential() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public Stream<T> parallel() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public Stream<T> unordered() {
+ throwIfTerminated();
+ return this;
+ }
+ }
+
+ /**
+ * Object to Object map spliterator.
+ *
+ * @param <U> the input type
+ * @param <T> the output type
+ */
+ private static final class MapToObjSpliterator<U, T> extends Spliterators.AbstractSpliterator<T> {
+ private final Function<? super U, ? extends T> map;
+ private final Spliterator<U> original;
+
+ public MapToObjSpliterator(Function<? super U, ? extends T> map, Spliterator<U> original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final Consumer<? super T> action) {
+ return original.tryAdvance(u -> action.accept(map.apply(u)));
+ }
+ }
+
+ /**
+ * Object to Int map spliterator.
+ *
+ * @param <T> the input type
+ */
+ private static final class MapToIntSpliterator<T> extends Spliterators.AbstractIntSpliterator {
+ private final ToIntFunction<? super T> map;
+ private final Spliterator<T> original;
+
+ public MapToIntSpliterator(ToIntFunction<? super T> map, Spliterator<T> original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final IntConsumer action) {
+ return original.tryAdvance(u -> action.accept(map.applyAsInt(u)));
+ }
+ }
+
+ /**
+ * Object to Long map spliterator.
+ *
+ * @param <T> the input type
+ */
+ private static final class MapToLongSpliterator<T> extends Spliterators.AbstractLongSpliterator {
+ private final ToLongFunction<? super T> map;
+ private final Spliterator<T> original;
+
+ public MapToLongSpliterator(ToLongFunction<? super T> map, Spliterator<T> original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final LongConsumer action) {
+ return original.tryAdvance(u -> action.accept(map.applyAsLong(u)));
+ }
+ }
+
+ /**
+ * Object to Double map spliterator.
+ *
+ * @param <T> the input type
+ */
+ private static final class MapToDoubleSpliterator<T>
+ extends Spliterators.AbstractDoubleSpliterator {
+ private final ToDoubleFunction<? super T> map;
+ private final Spliterator<T> original;
+
+ public MapToDoubleSpliterator(ToDoubleFunction<? super T> map, Spliterator<T> original) {
+ super(
+ original.estimateSize(),
+ original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
+ checkNotNull(map);
+ this.map = map;
+ this.original = original;
+ }
+
+ @Override
+ public boolean tryAdvance(final DoubleConsumer action) {
+ return original.tryAdvance(u -> action.accept(map.applyAsDouble(u)));
+ }
+ }
+
+ /**
+ * Object filter spliterator.
+ *
+ * @param <T> the type of data to iterate over
+ */
+ private static final class FilterSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
+ private final Predicate<? super T> filter;
+ private final Spliterator<T> original;
+
+ private boolean found;
+
+ public FilterSpliterator(Predicate<? super T> filter, Spliterator<T> original) {
+ super(original.estimateSize(), original.characteristics() & ~Spliterator.SIZED);
+ checkNotNull(filter);
+ this.filter = filter;
+ this.original = original;
+ }
+
+ @Override
+ public Comparator<? super T> getComparator() {
+ return original.getComparator();
+ }
+
+ @Override
+ public boolean tryAdvance(final Consumer<? super T> action) {
+ found = false;
+ while (!found
+ && original.tryAdvance(
+ item -> {
+ if (filter.test(item)) {
+ found = true;
+ action.accept(item);
+ }
+ })) {
+ // do nothing, work is done in tryAdvance
+ }
+
+ return found;
+ }
+ }
+
+ /**
+ * Object skip spliterator.
+ *
+ * @param <T> the type of data to iterate over
+ */
+ private static final class SkipSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
+ private long skip;
+ private final Spliterator<T> original;
+
+ public SkipSpliterator(long skip, Spliterator<T> original) {
+ super(
+ original.hasCharacteristics(Spliterator.SIZED)
+ ? Math.max(0, original.estimateSize() - skip)
+ : Long.MAX_VALUE,
+ original.characteristics());
+ this.skip = skip;
+ this.original = original;
+ }
+
+ @Override
+ public Comparator<? super T> getComparator() {
+ return original.getComparator();
+ }
+
+ @Override
+ public boolean tryAdvance(Consumer<? super T> action) {
+ while (skip > 0) {
+ if (!original.tryAdvance(ignore -> { })) {
+ return false;
+ }
+ skip--;
+ }
+ return original.tryAdvance(action);
+ }
+ }
+
+ /**
+ * Object limit spliterator.
+ *
+ * @param <T> the type of data to iterate over
+ */
+ private static final class LimitSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
+ private final long limit;
+ private final Spliterator<T> original;
+ private int position = 0;
+
+ public LimitSpliterator(long limit, Spliterator<T> original) {
+ super(
+ original.hasCharacteristics(Spliterator.SIZED)
+ ? Math.min(original.estimateSize(), limit)
+ : Long.MAX_VALUE,
+ original.characteristics());
+ this.limit = limit;
+ this.original = original;
+ }
+
+ @Override
+ public Comparator<? super T> getComparator() {
+ return original.getComparator();
+ }
+
+ @Override
+ public boolean tryAdvance(Consumer<? super T> action) {
+ if (position >= limit) {
+ return false;
+ }
+ boolean result = original.tryAdvance(action);
+ position++;
+ return result;
+ }
+ }
+
+ /**
+ * Value holder for various stream operations.
+ */
+ private static final class ValueConsumer<T> implements Consumer<T> {
+ T value;
+
+ @Override
+ public void accept(T value) {
+ this.value = value;
+ }
+ }
+
+ private final Spliterator<T> spliterator;
+
+ public StreamImpl(TerminatableStream<?> prev, Spliterator<T> spliterator) {
+ super(prev);
+ this.spliterator = spliterator;
+ }
+
+ // terminal
+ @Override
+ public Spliterator<T> spliterator() {
+ terminate();
+ return spliterator;
+ }
+
+ @Override
+ public Iterator<T> iterator() {
+ return Spliterators.iterator(spliterator());
+ }
+
+ @Override
+ public long count() {
+ terminate();
+ long count = 0;
+ while (spliterator.tryAdvance(a -> { })) {
+ count++;
+ }
+ return count;
+ }
+
+ @Override
+ public void forEach(Consumer<? super T> action) {
+ forEachOrdered(action);
+ }
+
+ @Override
+ public void forEachOrdered(Consumer<? super T> action) {
+ terminate();
+ spliterator.forEachRemaining(action);
+ }
+
+ @Override
+ public Object[] toArray() {
+ return toArray(Object[]::new);
+ }
+
+ @Override
+ public <A> A[] toArray(IntFunction<A[]> generator) {
+ List<T> collected = collect(Collectors.toList());
+ return collected.toArray(generator.apply(collected.size()));
+ }
+
+ @Override
+ public <R> R collect(
+ Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
+ return collect(
+ Collector.of(
+ supplier,
+ accumulator,
+ (a, b) -> {
+ combiner.accept(a, b);
+ return a;
+ }));
+ }
+
+ @Override
+ public <R, A> R collect(final Collector<? super T, A, R> collector) {
+ return collector
+ .finisher()
+ .apply(
+ reduce(
+ collector.supplier().get(),
+ (a, t) -> {
+ collector.accumulator().accept(a, t);
+ return a;
+ },
+ collector.combiner()));
+ }
+
+ @Override
+ public Optional<T> findFirst() {
+ terminate();
+ ValueConsumer<T> holder = new ValueConsumer<T>();
+ if (spliterator.tryAdvance(holder)) {
+ return Optional.of(holder.value);
+ }
+ return Optional.empty();
+ }
+
+ @Override
+ public Optional<T> findAny() {
+ return findFirst();
+ }
+
+ @Override
+ public boolean anyMatch(Predicate<? super T> predicate) {
+ return filter(predicate).findFirst().isPresent();
+ }
+
+ @Override
+ public boolean allMatch(final Predicate<? super T> predicate) {
+ return !anyMatch(predicate.negate());
+ }
+
+ @Override
+ public boolean noneMatch(final Predicate<? super T> predicate) {
+ return !anyMatch(predicate);
+ }
+
+ @Override
+ public Optional<T> min(final Comparator<? super T> comparator) {
+ return reduce(BinaryOperator.minBy(comparator));
+ }
+
+ @Override
+ public Optional<T> max(final Comparator<? super T> comparator) {
+ return reduce(BinaryOperator.maxBy(comparator));
+ }
+
+ @Override
+ public T reduce(T identity, BinaryOperator<T> accumulator) {
+ return reduce(identity, accumulator, accumulator);
+ }
+
+ @Override
+ public Optional<T> reduce(BinaryOperator<T> accumulator) {
+ ValueConsumer<T> consumer = new ValueConsumer<T>();
+ if (!spliterator.tryAdvance(consumer)) {
+ terminate();
+ return Optional.empty();
+ }
+ return Optional.of(reduce(consumer.value, accumulator));
+ }
+
+ // combiner is ignored, since we don't parallelize
+ @Override
+ public <U> U reduce(
+ U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
+ terminate();
+ final ValueConsumer<U> consumer = new ValueConsumer<U>();
+ consumer.value = identity;
+ spliterator.forEachRemaining(
+ item -> {
+ consumer.accept(accumulator.apply(consumer.value, item));
+ });
+ return consumer.value;
+ }
+ // end terminal
+
+ // intermediate
+ @Override
+ public Stream<T> filter(Predicate<? super T> predicate) {
+ throwIfTerminated();
+ return new StreamImpl<>(this, new FilterSpliterator<>(predicate, spliterator));
+ }
+
+ @Override
+ public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
+ throwIfTerminated();
+ return new StreamImpl<>(this, new MapToObjSpliterator<>(mapper, spliterator));
+ }
+
+ @Override
+ public IntStream mapToInt(ToIntFunction<? super T> mapper) {
+ throwIfTerminated();
+ return new IntStreamImpl(this, new MapToIntSpliterator<>(mapper, spliterator));
+ }
+
+ @Override
+ public LongStream mapToLong(ToLongFunction<? super T> mapper) {
+ throwIfTerminated();
+ return new LongStreamImpl(this, new MapToLongSpliterator<>(mapper, spliterator));
+ }
+
+ @Override
+ public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
+ throwIfTerminated();
+ return new DoubleStreamImpl(this, new MapToDoubleSpliterator<>(mapper, spliterator));
+ }
+
+ @Override
+ public <R> Stream<R> flatMap(final Function<? super T, ? extends Stream<? extends R>> mapper) {
+ throwIfTerminated();
+ final Spliterator<? extends Stream<? extends R>> spliteratorOfStreams =
+ new MapToObjSpliterator<>(mapper, spliterator);
+
+ AbstractSpliterator<R> flatMapSpliterator =
+ new Spliterators.AbstractSpliterator<R>(Long.MAX_VALUE, 0) {
+ Stream<? extends R> nextStream;
+ Spliterator<? extends R> next;
+
+ @Override
+ public boolean tryAdvance(Consumer<? super R> action) {
+ // look for a new spliterator
+ while (advanceToNextSpliterator()) {
+ // if we have one, try to read and use it
+ if (next.tryAdvance(action)) {
+ return true;
+ } else {
+ nextStream.close();
+ nextStream = null;
+ // failed, null it out so we can find another
+ next = null;
+ }
+ }
+ return false;
+ }
+
+ private boolean advanceToNextSpliterator() {
+ while (next == null) {
+ if (!spliteratorOfStreams.tryAdvance(
+ n -> {
+ if (n != null) {
+ nextStream = n;
+ next = n.spliterator();
+ }
+ })) {
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+
+ return new StreamImpl<R>(this, flatMapSpliterator);
+ }
+
+ @Override
+ public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
+ throwIfTerminated();
+ final Spliterator<? extends IntStream> spliteratorOfStreams =
+ new MapToObjSpliterator<>(mapper, spliterator);
+
+ AbstractIntSpliterator flatMapSpliterator =
+ new Spliterators.AbstractIntSpliterator(Long.MAX_VALUE, 0) {
+ IntStream nextStream;
+ Spliterator.OfInt next;
+
+ @Override
+ public boolean tryAdvance(IntConsumer action) {
+ // look for a new spliterator
+ while (advanceToNextSpliterator()) {
+ // if we have one, try to read and use it
+ if (next.tryAdvance(action)) {
+ return true;
+ } else {
+ nextStream.close();
+ nextStream = null;
+ // failed, null it out so we can find another
+ next = null;
+ }
+ }
+ return false;
+ }
+
+ private boolean advanceToNextSpliterator() {
+ while (next == null) {
+ if (!spliteratorOfStreams.tryAdvance(
+ n -> {
+ if (n != null) {
+ nextStream = n;
+ next = n.spliterator();
+ }
+ })) {
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+
+ return new IntStreamImpl(this, flatMapSpliterator);
+ }
+
+ @Override
+ public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
+ throwIfTerminated();
+ final Spliterator<? extends LongStream> spliteratorOfStreams =
+ new MapToObjSpliterator<>(mapper, spliterator);
+
+ AbstractLongSpliterator flatMapSpliterator =
+ new Spliterators.AbstractLongSpliterator(Long.MAX_VALUE, 0) {
+ LongStream nextStream;
+ Spliterator.OfLong next;
+
+ @Override
+ public boolean tryAdvance(LongConsumer action) {
+ // look for a new spliterator
+ while (advanceToNextSpliterator()) {
+ // if we have one, try to read and use it
+ if (next.tryAdvance(action)) {
+ return true;
+ } else {
+ nextStream.close();
+ nextStream = null;
+ // failed, null it out so we can find another
+ next = null;
+ }
+ }
+ return false;
+ }
+
+ private boolean advanceToNextSpliterator() {
+ while (next == null) {
+ if (!spliteratorOfStreams.tryAdvance(
+ n -> {
+ if (n != null) {
+ nextStream = n;
+ next = n.spliterator();
+ }
+ })) {
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+
+ return new LongStreamImpl(this, flatMapSpliterator);
+ }
+
+ @Override
+ public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
+ throwIfTerminated();
+ final Spliterator<? extends DoubleStream> spliteratorOfStreams =
+ new MapToObjSpliterator<>(mapper, spliterator);
+
+ AbstractDoubleSpliterator flatMapSpliterator =
+ new Spliterators.AbstractDoubleSpliterator(Long.MAX_VALUE, 0) {
+ DoubleStream nextStream;
+ Spliterator.OfDouble next;
+
+ @Override
+ public boolean tryAdvance(DoubleConsumer action) {
+ // look for a new spliterator
+ while (advanceToNextSpliterator()) {
+ // if we have one, try to read and use it
+ if (next.tryAdvance(action)) {
+ return true;
+ } else {
+ nextStream.close();
+ nextStream = null;
+ // failed, null it out so we can find another
+ next = null;
+ }
+ }
+ return false;
+ }
+
+ private boolean advanceToNextSpliterator() {
+ while (next == null) {
+ if (!spliteratorOfStreams.tryAdvance(
+ n -> {
+ if (n != null) {
+ nextStream = n;
+ next = n.spliterator();
+ }
+ })) {
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+
+ return new DoubleStreamImpl(this, flatMapSpliterator);
+ }
+
+ @Override
+ public Stream<T> distinct() {
+ throwIfTerminated();
+ HashSet<T> seen = new HashSet<>();
+ return filter(seen::add);
+ }
+
+ @Override
+ public Stream<T> sorted() {
+ throwIfTerminated();
+ Comparator<T> c = (Comparator) Comparator.naturalOrder();
+ return sorted(c);
+ }
+
+ @Override
+ public Stream<T> sorted(final Comparator<? super T> comparator) {
+ throwIfTerminated();
+
+ AbstractSpliterator<T> sortedSpliterator =
+ new Spliterators.AbstractSpliterator<T>(
+ spliterator.estimateSize(), spliterator.characteristics() | Spliterator.SORTED) {
+ Spliterator<T> ordered = null;
+
+ @Override
+ public Comparator<? super T> getComparator() {
+ return comparator == Comparator.naturalOrder() ? null : comparator;
+ }
+
+ @Override
+ public boolean tryAdvance(Consumer<? super T> action) {
+ if (ordered == null) {
+ List<T> list = new ArrayList<>();
+ spliterator.forEachRemaining(list::add);
+ Collections.sort(list, comparator);
+ ordered = list.spliterator();
+ }
+ return ordered.tryAdvance(action);
+ }
+ };
+
+ return new StreamImpl<>(this, sortedSpliterator);
+ }
+
+ @Override
+ public Stream<T> peek(final Consumer<? super T> action) {
+ checkNotNull(action);
+ throwIfTerminated();
+
+ AbstractSpliterator<T> peekSpliterator =
+ new Spliterators.AbstractSpliterator<T>(
+ spliterator.estimateSize(), spliterator.characteristics()) {
+ @Override
+ public boolean tryAdvance(final Consumer<? super T> innerAction) {
+ return spliterator.tryAdvance(
+ item -> {
+ action.accept(item);
+ innerAction.accept(item);
+ });
+ }
+ };
+
+ return new StreamImpl<>(this, peekSpliterator);
+ }
+
+ @Override
+ public Stream<T> limit(long maxSize) {
+ throwIfTerminated();
+ checkState(maxSize >= 0, "maxSize may not be negative");
+ return new StreamImpl<>(this, new LimitSpliterator<>(maxSize, spliterator));
+ }
+
+ @Override
+ public Stream<T> skip(long n) {
+ throwIfTerminated();
+ checkState(n >= 0, "n may not be negative");
+ if (n == 0) {
+ return this;
+ }
+ return new StreamImpl<>(this, new SkipSpliterator<>(n, spliterator));
+ }
+
+ @Override
+ public boolean isParallel() {
+ throwIfTerminated();
+ return false;
+ }
+
+ @Override
+ public Stream<T> sequential() {
+ throwIfTerminated();
+ return this;
+ }
+
+ @Override
+ public Stream<T> parallel() {
+ throwIfTerminated();
+ // do nothing, no such thing as gwt+parallel
+ return this;
+ }
+
+ @Override
+ public Stream<T> unordered() {
+ throwIfTerminated();
+ return this;
+ }
+}
diff --git a/user/super/com/google/gwt/emul/java/util/stream/StreamSupport.java b/user/super/com/google/gwt/emul/java/util/stream/StreamSupport.java
index 0c64d9e..3b37063 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/StreamSupport.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/StreamSupport.java
@@ -13,7 +13,6 @@
* License for the specific language governing permissions and limitations under
* the License.
*/
-
package java.util.stream;
import java.util.Spliterator;
@@ -26,7 +25,7 @@
public final class StreamSupport {
public static DoubleStream doubleStream(Spliterator.OfDouble spliterator, boolean parallel) {
- return new DoubleStream.DoubleStreamSource(null, spliterator);
+ return new DoubleStreamImpl(null, spliterator);
}
public static DoubleStream doubleStream(
@@ -41,7 +40,7 @@
}
public static IntStream intStream(Spliterator.OfInt spliterator, boolean parallel) {
- return new IntStream.IntStreamSource(null, spliterator);
+ return new IntStreamImpl(null, spliterator);
}
public static IntStream intStream(
@@ -56,7 +55,7 @@
}
public static LongStream longStream(Spliterator.OfLong spliterator, boolean parallel) {
- return new LongStream.LongStreamSource(null, spliterator);
+ return new LongStreamImpl(null, spliterator);
}
public static LongStream longStream(
@@ -73,7 +72,7 @@
}
public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
- return new Stream.StreamSource<T>(null, spliterator);
+ return new StreamImpl<T>(null, spliterator);
}
public static <T> Stream<T> stream(
