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

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

*** 94,103 ****
--- 94,108 ----
              default:
                  throw new IllegalStateException("Unknown shape " + shape);
          }
      }
  
+     @SuppressWarnings("unchecked")
+     private static <T> IntFunction<T[]> castingArray() {
+         return size -> (T[]) new Object[size];
+     }
+ 
      /**
       * Appends a "slice" operation to the provided stream.  The slice operation
       * may be may be skip-only, limit-only, or skip-and-limit.
       *
       * @param <T> the type of both input and output elements
*** 109,119 ****
      public static <T> Stream<T> makeRef(AbstractPipeline<?, T, ?> upstream,
                                         long skip, long limit) {
          if (skip < 0)
              throw new IllegalArgumentException("Skip must be non-negative: " + skip);
  
!         return new ReferencePipeline.StatefulOp<T,T>(upstream, StreamShape.REFERENCE,
                                                       flags(limit)) {
              Spliterator<T> unorderedSkipLimitSpliterator(Spliterator<T> s,
                                                           long skip, long limit, long sizeIfKnown) {
                  if (skip <= sizeIfKnown) {
                      // Use just the limit if the number of elements
--- 114,124 ----
      public static <T> Stream<T> makeRef(AbstractPipeline<?, T, ?> upstream,
                                          long skip, long limit) {
          if (skip < 0)
              throw new IllegalArgumentException("Skip must be non-negative: " + skip);
  
!         return new ReferencePipeline.StatefulOp<T, T>(upstream, StreamShape.REFERENCE,
                                                        flags(limit)) {
              Spliterator<T> unorderedSkipLimitSpliterator(Spliterator<T> s,
                                                           long skip, long limit, long sizeIfKnown) {
                  if (skip <= sizeIfKnown) {
                      // Use just the limit if the number of elements
*** 144,154 ****
                      //     SliceTask from say (size / k) to say min(size / k, 1 << 14)
                      //     This will limit the size of the buffers created at the leaf nodes
                      //     cancellation will be more aggressive cancelling later tasks
                      //     if the target slice size has been reached from a given task,
                      //     cancellation should also clear local results if any
!                     return new SliceTask<>(this, helper, spliterator, i -> (T[]) new Object[i], skip, limit).
                              invoke().spliterator();
                  }
              }
  
              @Override
--- 149,159 ----
                      //     SliceTask from say (size / k) to say min(size / k, 1 << 14)
                      //     This will limit the size of the buffers created at the leaf nodes
                      //     cancellation will be more aggressive cancelling later tasks
                      //     if the target slice size has been reached from a given task,
                      //     cancellation should also clear local results if any
!                     return new SliceTask<>(this, helper, spliterator, castingArray(), skip, limit).
                              invoke().spliterator();
                  }
              }
  
              @Override
*** 180,190 ****
                  }
              }
  
              @Override
              Sink<T> opWrapSink(int flags, Sink<T> sink) {
!                 return new Sink.ChainedReference<T>(sink) {
                      long n = skip;
                      long m = limit >= 0 ? limit : Long.MAX_VALUE;
  
                      @Override
                      public void begin(long size) {
--- 185,195 ----
                  }
              }
  
              @Override
              Sink<T> opWrapSink(int flags, Sink<T> sink) {
!                 return new Sink.ChainedReference<T, T>(sink) {
                      long n = skip;
                      long m = limit >= 0 ? limit : Long.MAX_VALUE;
  
                      @Override
                      public void begin(long size) {
*** 289,299 ****
                  }
              }
  
              @Override
              Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {
!                 return new Sink.ChainedInt(sink) {
                      long n = skip;
                      long m = limit >= 0 ? limit : Long.MAX_VALUE;
  
                      @Override
                      public void begin(long size) {
--- 294,304 ----
                  }
              }
  
              @Override
              Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {
!                 return new Sink.ChainedInt<Integer>(sink) {
                      long n = skip;
                      long m = limit >= 0 ? limit : Long.MAX_VALUE;
  
                      @Override
                      public void begin(long size) {
*** 398,408 ****
                  }
              }
  
              @Override
              Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
!                 return new Sink.ChainedLong(sink) {
                      long n = skip;
                      long m = limit >= 0 ? limit : Long.MAX_VALUE;
  
                      @Override
                      public void begin(long size) {
--- 403,413 ----
                  }
              }
  
              @Override
              Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
!                 return new Sink.ChainedLong<Long>(sink) {
                      long n = skip;
                      long m = limit >= 0 ? limit : Long.MAX_VALUE;
  
                      @Override
                      public void begin(long size) {
*** 507,517 ****
                  }
              }
  
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
!                 return new Sink.ChainedDouble(sink) {
                      long n = skip;
                      long m = limit >= 0 ? limit : Long.MAX_VALUE;
  
                      @Override
                      public void begin(long size) {
--- 512,522 ----
                  }
              }
  
              @Override
              Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
!                 return new Sink.ChainedDouble<Double>(sink) {
                      long n = skip;
                      long m = limit >= 0 ? limit : Long.MAX_VALUE;
  
                      @Override
                      public void begin(long size) {
*** 558,574 ****
          private final long targetOffset, targetSize;
          private long thisNodeSize;
  
          private volatile boolean completed;
  
!         SliceTask(AbstractPipeline<?, P_OUT, ?> op,
                    PipelineHelper<P_OUT> helper,
                    Spliterator<P_IN> spliterator,
                    IntFunction<P_OUT[]> generator,
                    long offset, long size) {
              super(helper, spliterator);
!             this.op = (AbstractPipeline<P_OUT, P_OUT, ?>) op;
              this.generator = generator;
              this.targetOffset = offset;
              this.targetSize = size;
          }
  
--- 563,579 ----
          private final long targetOffset, targetSize;
          private long thisNodeSize;
  
          private volatile boolean completed;
  
!         SliceTask(AbstractPipeline<P_OUT, P_OUT, ?> op,
                    PipelineHelper<P_OUT> helper,
                    Spliterator<P_IN> spliterator,
                    IntFunction<P_OUT[]> generator,
                    long offset, long size) {
              super(helper, spliterator);
!             this.op = op;
              this.generator = generator;
              this.targetOffset = offset;
              this.targetSize = size;
          }