@Override protected final Node<P_OUT> doLeaf() { Node.Builder<P_OUT> builder = helper.makeNodeBuilder(-1, generator); Sink<P_OUT> s = op.opWrapSink(helper.getStreamAndOpFlags(), builder); if (shortCircuited = helper.copyIntoWithCancel(helper.wrapSink(s), spliterator)) { // Cancel later nodes if the predicate returned false // during traversal cancelLaterNodes(); } Node<P_OUT> node = builder.build(); thisNodeSize = node.count(); return node; }
@Override public <P_IN> Node<Long> opEvaluateParallel(PipelineHelper<Long> helper, Spliterator<P_IN> spliterator, IntFunction<Long[]> generator) { if (StreamOpFlag.SORTED.isKnown(helper.getStreamAndOpFlags())) { return helper.evaluate(spliterator, false, generator); } else { Node.OfLong n = (Node.OfLong) helper.evaluate(spliterator, true, generator); long[] content = n.asPrimitiveArray(); java8.util.J8Arrays.parallelSort(content); return Nodes.node(content); } } }
@Override @SuppressWarnings("unchecked") protected T_NODE doLeaf() { T_BUILDER builder = builderFactory.apply(helper.exactOutputSizeIfKnown(spliterator)); return (T_NODE) helper.wrapAndCopyInto(builder, spliterator).build(); }
@Override protected final Node<P_OUT> doLeaf() { if (isRoot()) { long sizeIfKnown = StreamOpFlag.SIZED.isPreserved(op.sourceOrOpFlags) ? op.exactOutputSizeIfKnown(spliterator) : -1L; Node.Builder<P_OUT> nb = op.makeNodeBuilder(sizeIfKnown, generator); Sink<P_OUT> opSink = op.opWrapSink(helper.getStreamAndOpFlags(), nb); helper.copyIntoWithCancel(helper.wrapSink(opSink), spliterator); // There is no need to truncate since the op performs the // skipping and limiting of elements return nb.build(); } else { Node.Builder<P_OUT> nb = op.makeNodeBuilder(-1, generator); if (targetOffset == 0) { // limit only Sink<P_OUT> opSink = op.opWrapSink(helper.getStreamAndOpFlags(), nb); helper.copyIntoWithCancel(helper.wrapSink(opSink), spliterator); } else { helper.wrapAndCopyInto(nb, spliterator); } Node<P_OUT> node = nb.build(); thisNodeSize = node.count(); completed = true; spliterator = null; return node; } }
@Override public <S> Void evaluateSequential(PipelineHelper<T> helper, Spliterator<S> spliterator) { return helper.wrapAndCopyInto(this, spliterator).get(); }
DropWhileTask(AbstractPipeline<P_OUT, P_OUT, ?> op, PipelineHelper<P_OUT> helper, Spliterator<P_IN> spliterator, IntFunction<P_OUT[]> generator) { super(helper, spliterator); this.op = op; this.generator = generator; this.isOrdered = StreamOpFlag.ORDERED.isKnown(helper.getStreamAndOpFlags()); }
Node.Builder<T> nb = task.helper.makeNodeBuilder( task.helper.exactOutputSizeIfKnown(rightSplit), generator); task.node = task.helper.wrapAndCopyInto(nb, rightSplit).build(); task.spliterator = null;
@Override void initPartialTraversalState() { SpinedBuffer<P_OUT> b = new SpinedBuffer<>(); buffer = b; bufferSink = ph.wrapSink(b::accept); pusher = () -> spliterator.tryAdvance(bufferSink); }
@Override protected final Node<P_OUT> doLeaf() { boolean isChild = !isRoot(); // If this not the root and pipeline is ordered and size is known // then pre-size the builder long sizeIfKnown = isChild && isOrdered && StreamOpFlag.SIZED.isPreserved(op.sourceOrOpFlags) ? op.exactOutputSizeIfKnown(spliterator) : -1; Node.Builder<P_OUT> builder = helper.makeNodeBuilder(sizeIfKnown, generator); @SuppressWarnings("unchecked") DropWhileOp<P_OUT> dropOp = (DropWhileOp<P_OUT>) op; // If this leaf is the root then there is no merging on completion // and there is no need to retain dropped elements DropWhileSink<P_OUT> s = dropOp.opWrapSink(builder, isOrdered && isChild); helper.wrapAndCopyInto(s, spliterator); Node<P_OUT> node = builder.build(); thisNodeSize = node.count(); index = s.getDropCount(); return node; }
Spliterator<P_IN> spliterator, boolean flattenTree) { long size = helper.exactOutputSizeIfKnown(spliterator); if (size >= 0 && spliterator.hasCharacteristics(Spliterator.SUBSIZED)) { if (size >= MAX_ARRAY_SIZE)
targetSize = sizeThreshold = AbstractTask.suggestTargetSize(sizeEstimate); boolean isShortCircuit = StreamOpFlag.SHORT_CIRCUIT.isKnown(helper.getStreamAndOpFlags()); boolean forkRight = false; Sink<S> taskSink = sink; if (sizeEstimate <= sizeThreshold || (leftSplit = rightSplit.trySplit()) == null) { task.helper.copyInto(taskSink, rightSplit); break;
@Override protected final Node<P_OUT> doLeaf() { if (isRoot()) { long sizeIfKnown = StreamOpFlag.SIZED.isPreserved(op.sourceOrOpFlags) ? op.exactOutputSizeIfKnown(spliterator) : -1L; Node.Builder<P_OUT> nb = op.makeNodeBuilder(sizeIfKnown, generator); Sink<P_OUT> opSink = op.opWrapSink(helper.getStreamAndOpFlags(), nb); helper.copyIntoWithCancel(helper.wrapSink(opSink), spliterator); // There is no need to truncate since the op performs the // skipping and limiting of elements return nb.build(); } else { Node.Builder<P_OUT> nb = op.makeNodeBuilder(-1, generator); if (targetOffset == 0) { // limit only Sink<P_OUT> opSink = op.opWrapSink(helper.getStreamAndOpFlags(), nb); helper.copyIntoWithCancel(helper.wrapSink(opSink), spliterator); } else { helper.wrapAndCopyInto(nb, spliterator); } Node<P_OUT> node = nb.build(); thisNodeSize = node.count(); completed = true; spliterator = null; return node; } }
@Override public <S> Void evaluateSequential(PipelineHelper<T> helper, Spliterator<S> spliterator) { return helper.wrapAndCopyInto(this, spliterator).get(); }
TakeWhileTask(AbstractPipeline<P_OUT, P_OUT, ?> op, PipelineHelper<P_OUT> helper, Spliterator<P_IN> spliterator, IntFunction<P_OUT[]> generator) { super(helper, spliterator); this.op = op; this.generator = generator; this.isOrdered = StreamOpFlag.ORDERED.isKnown(helper.getStreamAndOpFlags()); }
Node.Builder<T> nb = task.helper.makeNodeBuilder( task.helper.exactOutputSizeIfKnown(rightSplit), generator); task.node = task.helper.wrapAndCopyInto(nb, rightSplit).build(); task.spliterator = null;
@Override void initPartialTraversalState() { SpinedBuffer<P_OUT> b = new SpinedBuffer<>(); buffer = b; bufferSink = ph.wrapSink(b::accept); pusher = () -> spliterator.tryAdvance(bufferSink); }
@Override protected final Node<P_OUT> doLeaf() { boolean isChild = !isRoot(); // If this not the root and pipeline is ordered and size is known // then pre-size the builder long sizeIfKnown = isChild && isOrdered && StreamOpFlag.SIZED.isPreserved(op.sourceOrOpFlags) ? op.exactOutputSizeIfKnown(spliterator) : -1; Node.Builder<P_OUT> builder = helper.makeNodeBuilder(sizeIfKnown, generator); @SuppressWarnings("unchecked") DropWhileOp<P_OUT> dropOp = (DropWhileOp<P_OUT>) op; // If this leaf is the root then there is no merging on completion // and there is no need to retain dropped elements DropWhileSink<P_OUT> s = dropOp.opWrapSink(builder, isOrdered && isChild); helper.wrapAndCopyInto(s, spliterator); Node<P_OUT> node = builder.build(); thisNodeSize = node.count(); index = s.getDropCount(); return node; }
Spliterator<P_IN> spliterator, boolean flattenTree) { long size = helper.exactOutputSizeIfKnown(spliterator); if (size >= 0 && spliterator.hasCharacteristics(Spliterator.SUBSIZED)) { if (size >= MAX_ARRAY_SIZE)
targetSize = sizeThreshold = AbstractTask.suggestTargetSize(sizeEstimate); boolean isShortCircuit = StreamOpFlag.SHORT_CIRCUIT.isKnown(helper.getStreamAndOpFlags()); boolean forkRight = false; Sink<S> taskSink = sink; if (sizeEstimate <= sizeThreshold || (leftSplit = rightSplit.trySplit()) == null) { task.helper.copyInto(taskSink, rightSplit); break;
@Override protected final Node<P_OUT> doLeaf() { Node.Builder<P_OUT> builder = helper.makeNodeBuilder(-1, generator); Sink<P_OUT> s = op.opWrapSink(helper.getStreamAndOpFlags(), builder); if (shortCircuited = helper.copyIntoWithCancel(helper.wrapSink(s), spliterator)) { // Cancel later nodes if the predicate returned false // during traversal cancelLaterNodes(); } Node<P_OUT> node = builder.build(); thisNodeSize = node.count(); return node; }