src/share/classes/java/util/stream/DoublePipeline.java

rev 7923 : 8023681: Fix raw type warning caused by Sink
Reviewed-by:

*** 189,199 ****
          Objects.requireNonNull(mapper);
          return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                         StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
!                 return new Sink.ChainedDouble(sink) {
                      @Override
                      public void accept(double t) {
                          downstream.accept(mapper.applyAsDouble(t));
                      }
                  };
--- 189,199 ----
          Objects.requireNonNull(mapper);
          return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                         StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
!                 return new Sink.ChainedDouble<Double>(sink) {
                      @Override
                      public void accept(double t) {
                          downstream.accept(mapper.applyAsDouble(t));
                      }
                  };
*** 206,218 ****
          Objects.requireNonNull(mapper);
          return new ReferencePipeline.StatelessOp<Double, U>(this, StreamShape.DOUBLE_VALUE,
                                                              StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<U> sink) {
!                 return new Sink.ChainedDouble(sink) {
                      @Override
-                     @SuppressWarnings("unchecked")
                      public void accept(double t) {
                          downstream.accept(mapper.apply(t));
                      }
                  };
              }
--- 206,217 ----
          Objects.requireNonNull(mapper);
          return new ReferencePipeline.StatelessOp<Double, U>(this, StreamShape.DOUBLE_VALUE,
                                                              StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<U> sink) {
!                 return new Sink.ChainedDouble<U>(sink) {
                      @Override
                      public void accept(double t) {
                          downstream.accept(mapper.apply(t));
                      }
                  };
              }
*** 224,234 ****
          Objects.requireNonNull(mapper);
          return new IntPipeline.StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                                     StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Integer> sink) {
!                 return new Sink.ChainedDouble(sink) {
                      @Override
                      public void accept(double t) {
                          downstream.accept(mapper.applyAsInt(t));
                      }
                  };
--- 223,233 ----
          Objects.requireNonNull(mapper);
          return new IntPipeline.StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                                     StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Integer> sink) {
!                 return new Sink.ChainedDouble<Integer>(sink) {
                      @Override
                      public void accept(double t) {
                          downstream.accept(mapper.applyAsInt(t));
                      }
                  };
*** 241,251 ****
          Objects.requireNonNull(mapper);
          return new LongPipeline.StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                                      StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Long> sink) {
!                 return new Sink.ChainedDouble(sink) {
                      @Override
                      public void accept(double t) {
                          downstream.accept(mapper.applyAsLong(t));
                      }
                  };
--- 240,250 ----
          Objects.requireNonNull(mapper);
          return new LongPipeline.StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                                      StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Long> sink) {
!                 return new Sink.ChainedDouble<Long>(sink) {
                      @Override
                      public void accept(double t) {
                          downstream.accept(mapper.applyAsLong(t));
                      }
                  };
*** 257,267 ****
      public final DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper) {
          return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                          StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT | StreamOpFlag.NOT_SIZED) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
!                 return new Sink.ChainedDouble(sink) {
                      @Override
                      public void begin(long size) {
                          downstream.begin(-1);
                      }
  
--- 256,266 ----
      public final DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper) {
          return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                          StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT | StreamOpFlag.NOT_SIZED) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
!                 return new Sink.ChainedDouble<Double>(sink) {
                      @Override
                      public void begin(long size) {
                          downstream.begin(-1);
                      }
  
*** 294,304 ****
          Objects.requireNonNull(predicate);
          return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                         StreamOpFlag.NOT_SIZED) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
!                 return new Sink.ChainedDouble(sink) {
                      @Override
                      public void begin(long size) {
                          downstream.begin(-1);
                      }
  
--- 293,303 ----
          Objects.requireNonNull(predicate);
          return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                         StreamOpFlag.NOT_SIZED) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
!                 return new Sink.ChainedDouble<Double>(sink) {
                      @Override
                      public void begin(long size) {
                          downstream.begin(-1);
                      }
  
*** 317,327 ****
          Objects.requireNonNull(consumer);
          return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                         0) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
!                 return new Sink.ChainedDouble(sink) {
                      @Override
                      public void accept(double t) {
                          consumer.accept(t);
                          downstream.accept(t);
                      }
--- 316,326 ----
          Objects.requireNonNull(consumer);
          return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                         0) {
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
!                 return new Sink.ChainedDouble<Double>(sink) {
                      @Override
                      public void accept(double t) {
                          consumer.accept(t);
                          downstream.accept(t);
                      }