More emulation

Author: zbynek

user/super/com/google/gwt/emul/java/util/stream/IntStream.java

@@ -61,6 +61,15 @@ default IntStream.Builder add(int t) {
     IntStream build();
   }
 
+  /**
+   * See <a
+   * href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/stream/IntStream.IntMapMultiConsumer.html">
+   * the official Java API doc</a> for details.
+   */
+  public interface IntMapMultiConsumer {
+    accept(int value, IntConsumer ic);
+  }
+
   static Builder builder() {
     return new Builder() {
       private int[] items = new int[0];
@@ -366,5 +375,14 @@ public boolean tryAdvance(IntConsumer action) {
     return StreamSupport.intStream(spliterator, false);
   }
 
+  default IntStream mapMulti(IntMapMultiConsumer mapper) {
+    return flatMapToInt(element -> {
+      List<Integer> buffer = new ArrayList<>();
+      IntConsumer consumer = buffer::add;
+      mapper.accept(element, consumer);
+      return buffer.stream().mapToInt(n -> n);
+    });
+  }
+
   int[] toArray();
 }

user/super/com/google/gwt/emul/java/util/stream/Stream.java

@@ -17,8 +17,10 @@
 
 import static javaemul.internal.InternalPreconditions.checkState;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.List;
 import java.util.Comparator;
 import java.util.Optional;
 import java.util.Spliterator;
@@ -28,8 +30,11 @@
 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;
@@ -327,6 +332,41 @@ public boolean tryAdvance(Consumer<? super T> action) {
     return StreamSupport.stream(spliterator, false);
   }
 
+  default public <R> Stream<R> mapMulti(BiConsumer<T, Consumer<? super R>> mapper) {
+    return flatMap(element -> {
+      List<R> buffer = new ArrayList<>();
+      mapper.accept(element, buffer::add);
+      return buffer.stream();
+    });
+  }
+
+  default DoubleStream mapMultiToDouble(BiConsumer<? super T, ? super DoubleConsumer> mapper) {
+    return flatMapToDouble(element -> {
+      List<Double> buffer = new ArrayList<>();
+      DoubleConsumer consumer = buffer::add;
+      mapper.accept(element, consumer);
+      return buffer.stream().mapToDouble(n -> n);
+    });
+  }
+
+  default IntStream mapMultiToInt(BiConsumer<? super T, ? super IntConsumer> mapper) {
+    return flatMapToInt(element -> {
+      List<Integer> buffer = new ArrayList<>();
+      IntConsumer consumer = buffer::add;
+      mapper.accept(element, consumer);
+      return buffer.stream().mapToInt(n -> n);
+    });
+  }
+
+  default LongStream mapMultiToLong(BiConsumer<? super T, ? super LongConsumer> mapper) {
+    return flatMapToLong(element -> {
+      List<Long> buffer = new ArrayList<>();
+      LongConsumer consumer = buffer::add;
+      mapper.accept(element, consumer);
+      return buffer.stream().mapToLong(n -> n);
+    });
+  }
+
   Object[] toArray();
 
   <A> A[] toArray(IntFunction<A[]> generator);