java8.util.stream.LongPipeline Maven / Gradle / Ivy
Show all versions of streamsupport Show documentation
/*
* Copyright (c) 2013, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java8.util.stream;
import java8.lang.Longs;
import java8.util.LongSummaryStatistics;
import java8.util.Objects;
import java8.util.PrimitiveIterator;
import java8.util.function.BiConsumer;
import java8.util.function.BinaryOperator;
import java8.util.function.IntFunction;
import java8.util.function.LongBinaryOperator;
import java8.util.function.LongConsumer;
import java8.util.function.LongFunction;
import java8.util.function.LongPredicate;
import java8.util.function.LongToDoubleFunction;
import java8.util.function.LongToIntFunction;
import java8.util.function.LongUnaryOperator;
import java8.util.function.ObjLongConsumer;
import java8.util.function.Supplier;
import java8.util.OptionalDouble;
import java8.util.OptionalLong;
import java8.util.Spliterator;
import java8.util.Spliterators;
/**
* Abstract base class for an intermediate pipeline stage or pipeline source
* stage implementing whose elements are of type {@code long}.
*
* @param type of elements in the upstream source
* @since 1.8
*/
abstract class LongPipeline
extends AbstractPipeline
implements LongStream {
/**
* Constructor for the head of a stream pipeline.
*
* @param source {@code Supplier} describing the stream source
* @param sourceFlags the source flags for the stream source, described in
* {@link StreamOpFlag}
* @param parallel {@code true} if the pipeline is parallel
*/
LongPipeline(Supplier> source,
int sourceFlags, boolean parallel) {
super(source, sourceFlags, parallel);
}
/**
* Constructor for the head of a stream pipeline.
*
* @param source {@code Spliterator} describing the stream source
* @param sourceFlags the source flags for the stream source, described in
* {@link StreamOpFlag}
* @param parallel {@code true} if the pipeline is parallel
*/
LongPipeline(Spliterator source,
int sourceFlags, boolean parallel) {
super(source, sourceFlags, parallel);
}
/**
* Constructor for appending an intermediate operation onto an existing pipeline.
*
* @param upstream the upstream element source.
* @param opFlags the operation flags
*/
LongPipeline(AbstractPipeline upstream, int opFlags) {
super(upstream, opFlags);
}
/**
* Adapt a {@code Sink to an {@code LongConsumer}, ideally simply
* by casting.
*/
private static LongConsumer adapt(Sink sink) {
if (sink instanceof LongConsumer) {
return (LongConsumer) sink;
} else {
return sink::accept;
}
}
/**
* Adapt a {@code Spliterator} to a {@code Spliterator.OfLong}.
*
* Implementation Note:
* The implementation attempts to cast to a Spliterator.OfLong, and throws
* an exception if this cast is not possible.
*/
private static Spliterator.OfLong adapt(Spliterator s) {
if (s instanceof Spliterator.OfLong) {
return (Spliterator.OfLong) s;
} else {
throw new UnsupportedOperationException("LongStream.adapt(Spliterator s)");
}
}
// Shape-specific methods
@Override
final StreamShape getOutputShape() {
return StreamShape.LONG_VALUE;
}
@Override
final Node evaluateToNode(PipelineHelper helper,
Spliterator spliterator,
boolean flattenTree,
IntFunction generator) {
return Nodes.collectLong(helper, spliterator, flattenTree);
}
@Override
final Spliterator wrap(PipelineHelper ph,
Supplier> supplier,
boolean isParallel) {
return new StreamSpliterators.LongWrappingSpliterator<>(ph, supplier, isParallel);
}
@Override
@SuppressWarnings("unchecked")
final Spliterator.OfLong lazySpliterator(Supplier> supplier) {
return new StreamSpliterators.DelegatingSpliterator.OfLong((Supplier) supplier);
}
@Override
final boolean forEachWithCancel(Spliterator spliterator, Sink sink) {
Spliterator.OfLong spl = adapt(spliterator);
LongConsumer adaptedSink = adapt(sink);
boolean cancelled;
do { } while (!(cancelled = sink.cancellationRequested()) && spl.tryAdvance(adaptedSink));
return cancelled;
}
@Override
final Node.Builder makeNodeBuilder(long exactSizeIfKnown, IntFunction generator) {
return Nodes.longBuilder(exactSizeIfKnown);
}
private Stream mapToObj(LongFunction mapper, int opFlags) {
return new ReferencePipeline.StatelessOp(this, StreamShape.LONG_VALUE, opFlags) {
@Override
Sink opWrapSink(int flags, Sink sink) {
return new Sink.ChainedLong(sink) {
@Override
public void accept(long t) {
downstream.accept(mapper.apply(t));
}
};
}
};
}
// LongStream
@Override
public final PrimitiveIterator.OfLong iterator() {
return Spliterators.iterator(spliterator());
}
@Override
public final Spliterator.OfLong spliterator() {
return adapt(super.spliterator());
}
// Stateless intermediate ops from LongStream
@Override
public final DoubleStream asDoubleStream() {
return new DoublePipeline.StatelessOp(this, StreamShape.LONG_VALUE, StreamOpFlag.NOT_DISTINCT) {
@Override
Sink opWrapSink(int flags, Sink sink) {
return new Sink.ChainedLong(sink) {
@Override
public void accept(long t) {
downstream.accept((double) t);
}
};
}
};
}
@Override
public final Stream boxed() {
return mapToObj(Long::valueOf, 0);
}
@Override
public final LongStream map(final LongUnaryOperator mapper) {
Objects.requireNonNull(mapper);
return new StatelessOp(this, StreamShape.LONG_VALUE,
StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
@Override
Sink opWrapSink(int flags, Sink sink) {
return new Sink.ChainedLong(sink) {
@Override
public void accept(long t) {
downstream.accept(mapper.applyAsLong(t));
}
};
}
};
}
@Override
public final Stream mapToObj(final LongFunction mapper) {
Objects.requireNonNull(mapper);
return mapToObj(mapper, StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT);
}
@Override
public final IntStream mapToInt(final LongToIntFunction mapper) {
Objects.requireNonNull(mapper);
return new IntPipeline.StatelessOp(this, StreamShape.LONG_VALUE,
StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
@Override
Sink opWrapSink(int flags, Sink sink) {
return new Sink.ChainedLong(sink) {
@Override
public void accept(long t) {
downstream.accept(mapper.applyAsInt(t));
}
};
}
};
}
@Override
public final DoubleStream mapToDouble(final LongToDoubleFunction mapper) {
Objects.requireNonNull(mapper);
return new DoublePipeline.StatelessOp(this, StreamShape.LONG_VALUE,
StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
@Override
Sink opWrapSink(int flags, Sink sink) {
return new Sink.ChainedLong(sink) {
@Override
public void accept(long t) {
downstream.accept(mapper.applyAsDouble(t));
}
};
}
};
}
@Override
public final LongStream flatMap(final LongFunction mapper) {
Objects.requireNonNull(mapper);
return new StatelessOp(this, StreamShape.LONG_VALUE,
StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT | StreamOpFlag.NOT_SIZED) {
@Override
Sink opWrapSink(int flags, Sink sink) {
return new Sink.ChainedLong(sink) {
@Override
public void begin(long size) {
downstream.begin(-1);
}
@Override
public void accept(long t) {
LongStream result = null;
try {
result = mapper.apply(t);
// We can do better than this too; optimize for depth=0 case and just grab spliterator and forEach it
if (result != null) {
result.sequential().forEach(i -> downstream.accept(i));
}
} finally {
if (result != null) {
result.close();
}
}
}
};
}
};
}
@Override
public LongStream unordered() {
if (!isOrdered()) {
return this;
}
return new StatelessOp(this, StreamShape.LONG_VALUE, StreamOpFlag.NOT_ORDERED) {
@Override
Sink opWrapSink(int flags, Sink sink) {
return sink;
}
};
}
@Override
public final LongStream filter(final LongPredicate predicate) {
Objects.requireNonNull(predicate);
return new StatelessOp(this, StreamShape.LONG_VALUE,
StreamOpFlag.NOT_SIZED) {
@Override
Sink opWrapSink(int flags, Sink 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))
downstream.accept(t);
}
};
}
};
}
@Override
public final LongStream peek(final LongConsumer action) {
Objects.requireNonNull(action);
return new StatelessOp(this, StreamShape.LONG_VALUE,
0) {
@Override
Sink opWrapSink(int flags, Sink sink) {
return new Sink.ChainedLong(sink) {
@Override
public void accept(long t) {
action.accept(t);
downstream.accept(t);
}
};
}
};
}
// Stateful intermediate ops from LongStream
@Override
public final LongStream limit(long maxSize) {
if (maxSize < 0)
throw new IllegalArgumentException(Long.toString(maxSize));
return SliceOps.makeLong(this, 0, maxSize);
}
@Override
public final LongStream skip(long n) {
if (n < 0)
throw new IllegalArgumentException(Long.toString(n));
if (n == 0)
return this;
else
return SliceOps.makeLong(this, n, -1);
}
@Override
public final LongStream takeWhile(LongPredicate predicate) {
return WhileOps.makeTakeWhileLong(this, predicate);
}
@Override
public final LongStream dropWhile(LongPredicate predicate) {
return WhileOps.makeDropWhileLong(this, predicate);
}
@Override
public final LongStream sorted() {
return SortedOps.makeLong(this);
}
@Override
public final LongStream distinct() {
// While functional and quick to implement, this approach is not very efficient.
// An efficient version requires a long-specific map/set implementation.
return boxed().distinct().mapToLong(i -> (long) i);
}
// Terminal ops from LongStream
@Override
public void forEach(LongConsumer action) {
evaluate(ForEachOps.makeLong(action, false));
}
@Override
public void forEachOrdered(LongConsumer action) {
evaluate(ForEachOps.makeLong(action, true));
}
@Override
public final long sum() {
// use better algorithm to compensate for intermediate overflow?
return reduce(0, Longs::sum);
}
@Override
public final OptionalLong min() {
return reduce(Math::min);
}
@Override
public final OptionalLong max() {
return reduce(Math::max);
}
@Override
public final OptionalDouble average() {
long[] avg = collect(() -> new long[2],
(ll, i) -> {
ll[0]++;
ll[1] += i;
},
(ll, rr) -> {
ll[0] += rr[0];
ll[1] += rr[1];
});
return avg[0] > 0
? OptionalDouble.of((double) avg[1] / avg[0])
: OptionalDouble.empty();
}
@Override
public final long count() {
return evaluate(ReduceOps.makeLongCounting());
}
@Override
public final LongSummaryStatistics summaryStatistics() {
return collect(LongSummaryStatistics::new, LongSummaryStatistics::accept,
LongSummaryStatistics::combine);
}
@Override
public final long reduce(long identity, LongBinaryOperator op) {
return evaluate(ReduceOps.makeLong(identity, op));
}
@Override
public final OptionalLong reduce(LongBinaryOperator op) {
return evaluate(ReduceOps.makeLong(op));
}
@Override
public final R collect(Supplier supplier,
ObjLongConsumer accumulator,
final BiConsumer combiner) {
Objects.requireNonNull(combiner);
BinaryOperator operator = (left, right) -> {
combiner.accept(left, right);
return left;
};
return evaluate(ReduceOps.makeLong(supplier, accumulator, operator));
}
@Override
public final boolean anyMatch(LongPredicate predicate) {
return evaluate(MatchOps.makeLong(predicate, MatchOps.MatchKind.ANY));
}
@Override
public final boolean allMatch(LongPredicate predicate) {
return evaluate(MatchOps.makeLong(predicate, MatchOps.MatchKind.ALL));
}
@Override
public final boolean noneMatch(LongPredicate predicate) {
return evaluate(MatchOps.makeLong(predicate, MatchOps.MatchKind.NONE));
}
@Override
public final OptionalLong findFirst() {
return evaluate(FindOps.makeLong(true));
}
@Override
public final OptionalLong findAny() {
return evaluate(FindOps.makeLong(false));
}
@Override
public final long[] toArray() {
return Nodes.flattenLong((Node.OfLong) evaluateToArrayNode(Long[]::new))
.asPrimitiveArray();
}
//
/**
* Source stage of a LongPipeline.
*
* @param type of elements in the upstream source
* @since 1.8
*/
static class Head extends LongPipeline {
/**
* Constructor for the source stage of a LongStream.
*
* @param source {@code Supplier} describing the stream
* source
* @param sourceFlags the source flags for the stream source, described
* in {@link StreamOpFlag}
* @param parallel {@code true} if the pipeline is parallel
*/
Head(Supplier> source,
int sourceFlags, boolean parallel) {
super(source, sourceFlags, parallel);
}
/**
* Constructor for the source stage of a LongStream.
*
* @param source {@code Spliterator} describing the stream source
* @param sourceFlags the source flags for the stream source, described
* in {@link StreamOpFlag}
* @param parallel {@code true} if the pipeline is parallel
*/
Head(Spliterator source,
int sourceFlags, boolean parallel) {
super(source, sourceFlags, parallel);
}
@Override
final boolean opIsStateful() {
throw new UnsupportedOperationException();
}
@Override
final Sink opWrapSink(int flags, Sink sink) {
throw new UnsupportedOperationException();
}
// Optimized sequential terminal operations for the head of the pipeline
@Override
public void forEach(LongConsumer action) {
if (!isParallel()) {
adapt(sourceStageSpliterator()).forEachRemaining(action);
} else {
super.forEach(action);
}
}
@Override
public void forEachOrdered(LongConsumer action) {
if (!isParallel()) {
adapt(sourceStageSpliterator()).forEachRemaining(action);
} else {
super.forEachOrdered(action);
}
}
}
/** Base class for a stateless intermediate stage of a LongStream.
*
* @param type of elements in the upstream source
* @since 1.8
*/
abstract static class StatelessOp extends LongPipeline {
/**
* Construct a new LongStream by appending a stateless intermediate
* operation to an existing stream.
* @param upstream The upstream pipeline stage
* @param inputShape The stream shape for the upstream pipeline stage
* @param opFlags Operation flags for the new stage
*/
StatelessOp(AbstractPipeline upstream,
StreamShape inputShape,
int opFlags) {
super(upstream, opFlags);
}
@Override
final boolean opIsStateful() {
return false;
}
}
/**
* Base class for a stateful intermediate stage of a LongStream.
*
* @param type of elements in the upstream source
* @since 1.8
*/
abstract static class StatefulOp extends LongPipeline {
/**
* Construct a new LongStream by appending a stateful intermediate
* operation to an existing stream.
* @param upstream The upstream pipeline stage
* @param inputShape The stream shape for the upstream pipeline stage
* @param opFlags Operation flags for the new stage
*/
StatefulOp(AbstractPipeline upstream,
StreamShape inputShape,
int opFlags) {
super(upstream, opFlags);
}
@Override
final boolean opIsStateful() {
return true;
}
@Override
abstract Node opEvaluateParallel(PipelineHelper helper,
Spliterator spliterator,
IntFunction generator);
}
}