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

Print this page
rev 7633 : 8017513: Support for closeable streams
Reviewed-by:
Contributed-by: brian.goetz@oracle.com


 265                     }
 266                 };
 267             }
 268         };
 269     }
 270 
 271     @Override
 272     public final LongStream flatMap(LongFunction<? extends LongStream> mapper) {
 273         return new StatelessOp<Long>(this, StreamShape.LONG_VALUE,
 274                                      StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT | StreamOpFlag.NOT_SIZED) {
 275             @Override
 276             Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
 277                 return new Sink.ChainedLong(sink) {
 278                     @Override
 279                     public void begin(long size) {
 280                         downstream.begin(-1);
 281                     }
 282 
 283                     @Override
 284                     public void accept(long t) {

 285                         // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it
 286                         LongStream result = mapper.apply(t);
 287                         if (result != null)
 288                             result.sequential().forEach(i -> downstream.accept(i));

 289                     }
 290                 };
 291             }
 292         };
 293     }
 294 
 295     @Override
 296     public LongStream unordered() {
 297         if (!isOrdered())
 298             return this;
 299         return new StatelessOp<Long>(this, StreamShape.LONG_VALUE, StreamOpFlag.NOT_ORDERED) {
 300             @Override
 301             Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
 302                 return sink;
 303             }
 304         };
 305     }
 306 
 307     @Override
 308     public final LongStream filter(LongPredicate predicate) {




 265                     }
 266                 };
 267             }
 268         };
 269     }
 270 
 271     @Override
 272     public final LongStream flatMap(LongFunction<? extends LongStream> mapper) {
 273         return new StatelessOp<Long>(this, StreamShape.LONG_VALUE,
 274                                      StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT | StreamOpFlag.NOT_SIZED) {
 275             @Override
 276             Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
 277                 return new Sink.ChainedLong(sink) {
 278                     @Override
 279                     public void begin(long size) {
 280                         downstream.begin(-1);
 281                     }
 282 
 283                     @Override
 284                     public void accept(long t) {
 285                         try (LongStream result = mapper.apply(t)) {
 286                             // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it

 287                             if (result != null)
 288                                 result.sequential().forEach(i -> downstream.accept(i));
 289                         }
 290                     }
 291                 };
 292             }
 293         };
 294     }
 295 
 296     @Override
 297     public LongStream unordered() {
 298         if (!isOrdered())
 299             return this;
 300         return new StatelessOp<Long>(this, StreamShape.LONG_VALUE, StreamOpFlag.NOT_ORDERED) {
 301             @Override
 302             Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
 303                 return sink;
 304             }
 305         };
 306     }
 307 
 308     @Override
 309     public final LongStream filter(LongPredicate predicate) {