jdk/src/java.base/share/classes/java/util/stream/LongPipeline.java
changeset 37721 1258d14cf2cc
parent 31644 dbca10d053fd
equal deleted inserted replaced
37720:45cd7cc65382 37721:1258d14cf2cc
     1 /*
     1 /*
     2  * Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
     2  * Copyright (c) 2013, 2016, Oracle and/or its affiliates. All rights reserved.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     4  *
     4  *
     5  * This code is free software; you can redistribute it and/or modify it
     5  * This code is free software; you can redistribute it and/or modify it
     6  * under the terms of the GNU General Public License version 2 only, as
     6  * under the terms of the GNU General Public License version 2 only, as
     7  * published by the Free Software Foundation.  Oracle designates this
     7  * published by the Free Software Foundation.  Oracle designates this
   165     @Override
   165     @Override
   166     final Node.Builder<Long> makeNodeBuilder(long exactSizeIfKnown, IntFunction<Long[]> generator) {
   166     final Node.Builder<Long> makeNodeBuilder(long exactSizeIfKnown, IntFunction<Long[]> generator) {
   167         return Nodes.longBuilder(exactSizeIfKnown);
   167         return Nodes.longBuilder(exactSizeIfKnown);
   168     }
   168     }
   169 
   169 
       
   170     private <U> Stream<U> mapToObj(LongFunction<? extends U> mapper, int opFlags) {
       
   171         return new ReferencePipeline.StatelessOp<Long, U>(this, StreamShape.LONG_VALUE, opFlags) {
       
   172             @Override
       
   173             Sink<Long> opWrapSink(int flags, Sink<U> sink) {
       
   174                 return new Sink.ChainedLong<U>(sink) {
       
   175                     @Override
       
   176                     public void accept(long t) {
       
   177                         downstream.accept(mapper.apply(t));
       
   178                     }
       
   179                 };
       
   180             }
       
   181         };
       
   182     }
   170 
   183 
   171     // LongStream
   184     // LongStream
   172 
   185 
   173     @Override
   186     @Override
   174     public final PrimitiveIterator.OfLong iterator() {
   187     public final PrimitiveIterator.OfLong iterator() {
   182 
   195 
   183     // Stateless intermediate ops from LongStream
   196     // Stateless intermediate ops from LongStream
   184 
   197 
   185     @Override
   198     @Override
   186     public final DoubleStream asDoubleStream() {
   199     public final DoubleStream asDoubleStream() {
   187         return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
   200         return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE, StreamOpFlag.NOT_DISTINCT) {
   188                                                     StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
       
   189             @Override
   201             @Override
   190             Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
   202             Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
   191                 return new Sink.ChainedLong<Double>(sink) {
   203                 return new Sink.ChainedLong<Double>(sink) {
   192                     @Override
   204                     @Override
   193                     public void accept(long t) {
   205                     public void accept(long t) {
   198         };
   210         };
   199     }
   211     }
   200 
   212 
   201     @Override
   213     @Override
   202     public final Stream<Long> boxed() {
   214     public final Stream<Long> boxed() {
   203         return mapToObj(Long::valueOf);
   215         return mapToObj(Long::valueOf, 0);
   204     }
   216     }
   205 
   217 
   206     @Override
   218     @Override
   207     public final LongStream map(LongUnaryOperator mapper) {
   219     public final LongStream map(LongUnaryOperator mapper) {
   208         Objects.requireNonNull(mapper);
   220         Objects.requireNonNull(mapper);
   221     }
   233     }
   222 
   234 
   223     @Override
   235     @Override
   224     public final <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
   236     public final <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
   225         Objects.requireNonNull(mapper);
   237         Objects.requireNonNull(mapper);
   226         return new ReferencePipeline.StatelessOp<Long, U>(this, StreamShape.LONG_VALUE,
   238         return mapToObj(mapper, StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT);
   227                                                           StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
       
   228             @Override
       
   229             Sink<Long> opWrapSink(int flags, Sink<U> sink) {
       
   230                 return new Sink.ChainedLong<U>(sink) {
       
   231                     @Override
       
   232                     public void accept(long t) {
       
   233                         downstream.accept(mapper.apply(t));
       
   234                     }
       
   235                 };
       
   236             }
       
   237         };
       
   238     }
   239     }
   239 
   240 
   240     @Override
   241     @Override
   241     public final IntStream mapToInt(LongToIntFunction mapper) {
   242     public final IntStream mapToInt(LongToIntFunction mapper) {
   242         Objects.requireNonNull(mapper);
   243         Objects.requireNonNull(mapper);