From ffb64db01f11a9e22dce7d4335081ce633208783 Mon Sep 17 00:00:00 2001
From: psandoz <unknown>
Date: Thu, 20 Jun 2013 11:02:28 +0200
Subject: [PATCH] 8016324: filter/flatMap pipeline sinks should pass size
 information to downstream sink Reviewed-by: chegar, mduigou Contributed-by:
 Brian Goetz <brian.goetz@oracle.com>

---
 .../java/util/stream/DoublePipeline.java      | 11 +++++++
 .../classes/java/util/stream/IntPipeline.java | 11 +++++++
 .../java/util/stream/LongPipeline.java        | 11 +++++++
 .../java/util/stream/ReferencePipeline.java   | 29 +++++++++++++++++++
 4 files changed, 62 insertions(+)

diff --git a/src/share/classes/java/util/stream/DoublePipeline.java b/src/share/classes/java/util/stream/DoublePipeline.java
index c934445b8..52fd60f41 100644
--- a/src/share/classes/java/util/stream/DoublePipeline.java
+++ b/src/share/classes/java/util/stream/DoublePipeline.java
@@ -258,6 +258,12 @@ abstract class DoublePipeline<E_IN>
             @Override
             Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
                 return new Sink.ChainedDouble(sink) {
+                    @Override
+                    public void begin(long size) {
+                        downstream.begin(-1);
+                    }
+
+                    @Override
                     public void accept(double t) {
                         // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it
                         DoubleStream result = mapper.apply(t);
@@ -289,6 +295,11 @@ abstract class DoublePipeline<E_IN>
             @Override
             Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
                 return new Sink.ChainedDouble(sink) {
+                    @Override
+                    public void begin(long size) {
+                        downstream.begin(-1);
+                    }
+
                     @Override
                     public void accept(double t) {
                         if (predicate.test(t))
diff --git a/src/share/classes/java/util/stream/IntPipeline.java b/src/share/classes/java/util/stream/IntPipeline.java
index aa7155abb..10cfb8907 100644
--- a/src/share/classes/java/util/stream/IntPipeline.java
+++ b/src/share/classes/java/util/stream/IntPipeline.java
@@ -294,6 +294,12 @@ abstract class IntPipeline<E_IN>
             @Override
             Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {
                 return new Sink.ChainedInt(sink) {
+                    @Override
+                    public void begin(long size) {
+                        downstream.begin(-1);
+                    }
+
+                    @Override
                     public void accept(int t) {
                         // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it
                         IntStream result = mapper.apply(t);
@@ -325,6 +331,11 @@ abstract class IntPipeline<E_IN>
             @Override
             Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {
                 return new Sink.ChainedInt(sink) {
+                    @Override
+                    public void begin(long size) {
+                        downstream.begin(-1);
+                    }
+
                     @Override
                     public void accept(int t) {
                         if (predicate.test(t))
diff --git a/src/share/classes/java/util/stream/LongPipeline.java b/src/share/classes/java/util/stream/LongPipeline.java
index 9cbc9785b..e52a5cade 100644
--- a/src/share/classes/java/util/stream/LongPipeline.java
+++ b/src/share/classes/java/util/stream/LongPipeline.java
@@ -275,6 +275,12 @@ abstract class LongPipeline<E_IN>
             @Override
             Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
                 return new Sink.ChainedLong(sink) {
+                    @Override
+                    public void begin(long size) {
+                        downstream.begin(-1);
+                    }
+
+                    @Override
                     public void accept(long t) {
                         // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it
                         LongStream result = mapper.apply(t);
@@ -306,6 +312,11 @@ abstract class LongPipeline<E_IN>
             @Override
             Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
                 return new Sink.ChainedLong(sink) {
+                    @Override
+                    public void begin(long size) {
+                        downstream.begin(-1);
+                    }
+
                     @Override
                     public void accept(long t) {
                         if (predicate.test(t))
diff --git a/src/share/classes/java/util/stream/ReferencePipeline.java b/src/share/classes/java/util/stream/ReferencePipeline.java
index 92a139fa6..6e3beca1f 100644
--- a/src/share/classes/java/util/stream/ReferencePipeline.java
+++ b/src/share/classes/java/util/stream/ReferencePipeline.java
@@ -165,6 +165,11 @@ abstract class ReferencePipeline<P_IN, P_OUT>
             @Override
             Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) {
                 return new Sink.ChainedReference<P_OUT>(sink) {
+                    @Override
+                    public void begin(long size) {
+                        downstream.begin(-1);
+                    }
+
                     @Override
                     public void accept(P_OUT u) {
                         if (predicate.test(u))
@@ -252,6 +257,12 @@ abstract class ReferencePipeline<P_IN, P_OUT>
             @Override
             Sink<P_OUT> opWrapSink(int flags, Sink<R> sink) {
                 return new Sink.ChainedReference<P_OUT>(sink) {
+                    @Override
+                    public void begin(long size) {
+                        downstream.begin(-1);
+                    }
+
+                    @Override
                     public void accept(P_OUT u) {
                         // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it
                         Stream<? extends R> result = mapper.apply(u);
@@ -273,6 +284,12 @@ abstract class ReferencePipeline<P_IN, P_OUT>
             Sink<P_OUT> opWrapSink(int flags, Sink<Integer> sink) {
                 return new Sink.ChainedReference<P_OUT>(sink) {
                     IntConsumer downstreamAsInt = downstream::accept;
+                    @Override
+                    public void begin(long size) {
+                        downstream.begin(-1);
+                    }
+
+                    @Override
                     public void accept(P_OUT u) {
                         // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it
                         IntStream result = mapper.apply(u);
@@ -294,6 +311,12 @@ abstract class ReferencePipeline<P_IN, P_OUT>
             Sink<P_OUT> opWrapSink(int flags, Sink<Double> sink) {
                 return new Sink.ChainedReference<P_OUT>(sink) {
                     DoubleConsumer downstreamAsDouble = downstream::accept;
+                    @Override
+                    public void begin(long size) {
+                        downstream.begin(-1);
+                    }
+
+                    @Override
                     public void accept(P_OUT u) {
                         // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it
                         DoubleStream result = mapper.apply(u);
@@ -315,6 +338,12 @@ abstract class ReferencePipeline<P_IN, P_OUT>
             Sink<P_OUT> opWrapSink(int flags, Sink<Long> sink) {
                 return new Sink.ChainedReference<P_OUT>(sink) {
                     LongConsumer downstreamAsLong = downstream::accept;
+                    @Override
+                    public void begin(long size) {
+                        downstream.begin(-1);
+                    }
+
+                    @Override
                     public void accept(P_OUT u) {
                         // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it
                         LongStream result = mapper.apply(u);
-- 
GitLab