1 /*
2 * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
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
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package java.util.stream;
26
27 import java.util.Objects;
28 import java.util.Spliterator;
29 import java.util.function.IntFunction;
30 import java.util.function.Supplier;
31
32 /**
33 * Abstract base class for "pipeline" classes, which are the core
34 * implementations of the Stream interface and its primitive specializations.
35 * Manages construction and evaluation of stream pipelines.
36 *
37 * <p>An {@code AbstractPipeline} represents an initial portion of a stream
38 * pipeline, encapsulating a stream source and zero or more intermediate
39 * operations. The individual {@code AbstractPipeline} objects are often
40 * referred to as <em>stages</em>, where each stage describes either the stream
41 * source or an intermediate operation.
42 *
43 * <p>A concrete intermediate stage is generally built from an
44 * {@code AbstractPipeline}, a shape-specific pipeline class which extends it
45 * (e.g., {@code IntPipeline}) which is also abstract, and an operation-specific
46 * concrete class which extends that. {@code AbstractPipeline} contains most of
47 * the mechanics of evaluating the pipeline, and implements methods that will be
48 * used by the operation; the shape-specific classes add helper methods for
49 * dealing with collection of results into the appropriate shape-specific
50 * containers.
51 *
52 * <p>After chaining a new intermediate operation, or executing a terminal
53 * operation, the stream is considered to be consumed, and no more intermediate
54 * or terminal operations are permitted on this stream instance.
55 *
56 * @implNote
57 * <p>For sequential streams, and parallel streams without
58 * <a href="package-summary.html#StreamOps">stateful intermediate
59 * operations</a>, parallel streams, pipeline evaluation is done in a single
60 * pass that "jams" all the operations together. For parallel streams with
61 * stateful operations, execution is divided into segments, where each
62 * stateful operations marks the end of a segment, and each segment is
63 * evaluated separately and the result used as the input to the next
64 * segment. In all cases, the source data is not consumed until a terminal
65 * operation begins.
66 *
67 * @param <E_IN> type of input elements
68 * @param <E_OUT> type of output elements
69 * @param <S> type of the subclass implementing {@code BaseStream}
70 * @since 1.8
71 */
72 abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>>
73 extends PipelineHelper<E_OUT> implements BaseStream<E_OUT, S> {
74 private static final String MSG_STREAM_LINKED = "stream has already been operated upon or closed";
75 private static final String MSG_CONSUMED = "source already consumed or closed";
76
77 /**
78 * Backlink to the head of the pipeline chain (self if this is the source
79 * stage).
80 */
81 @SuppressWarnings("rawtypes")
82 private final AbstractPipeline sourceStage;
83
84 /**
85 * The "upstream" pipeline, or null if this is the source stage.
86 */
87 @SuppressWarnings("rawtypes")
88 private final AbstractPipeline previousStage;
89
90 /**
91 * The operation flags for the intermediate operation represented by this
92 * pipeline object.
93 */
94 protected final int sourceOrOpFlags;
95
96 /**
97 * The next stage in the pipeline, or null if this is the last stage.
98 * Effectively final at the point of linking to the next pipeline.
99 */
100 @SuppressWarnings("rawtypes")
101 private AbstractPipeline nextStage;
102
103 /**
104 * The number of intermediate operations between this pipeline object
105 * and the stream source if sequential, or the previous stateful if parallel.
106 * Valid at the point of pipeline preparation for evaluation.
107 */
108 private int depth;
109
110 /**
111 * The combined source and operation flags for the source and all operations
112 * up to and including the operation represented by this pipeline object.
113 * Valid at the point of pipeline preparation for evaluation.
114 */
115 private int combinedFlags;
116
117 /**
118 * The source spliterator. Only valid for the head pipeline.
119 * Before the pipeline is consumed if non-null then {@code sourceSupplier}
120 * must be null. After the pipeline is consumed if non-null then is set to
121 * null.
122 */
123 private Spliterator<?> sourceSpliterator;
124
125 /**
126 * The source supplier. Only valid for the head pipeline. Before the
127 * pipeline is consumed if non-null then {@code sourceSpliterator} must be
128 * null. After the pipeline is consumed if non-null then is set to null.
129 */
130 private Supplier<? extends Spliterator<?>> sourceSupplier;
131
132 /**
133 * True if this pipeline has been linked or consumed
134 */
135 private boolean linkedOrConsumed;
136
137 /**
138 * True if there are any stateful ops in the pipeline; only valid for the
139 * source stage.
140 */
141 private boolean sourceAnyStateful;
142
143 private Runnable sourceCloseAction;
144
145 /**
146 * True if pipeline is parallel, otherwise the pipeline is sequential; only
147 * valid for the source stage.
148 */
149 private boolean parallel;
150
151 /**
152 * Constructor for the head of a stream pipeline.
153 *
154 * @param source {@code Supplier<Spliterator>} describing the stream source
155 * @param sourceFlags The source flags for the stream source, described in
156 * {@link StreamOpFlag}
157 * @param parallel True if the pipeline is parallel
158 */
159 AbstractPipeline(Supplier<? extends Spliterator<?>> source,
160 int sourceFlags, boolean parallel) {
161 this.previousStage = null;
162 this.sourceSupplier = source;
163 this.sourceStage = this;
164 this.sourceOrOpFlags = sourceFlags & StreamOpFlag.STREAM_MASK;
165 // The following is an optimization of:
166 // StreamOpFlag.combineOpFlags(sourceOrOpFlags, StreamOpFlag.INITIAL_OPS_VALUE);
167 this.combinedFlags = (~(sourceOrOpFlags << 1)) & StreamOpFlag.INITIAL_OPS_VALUE;
168 this.depth = 0;
169 this.parallel = parallel;
170 }
171
172 /**
173 * Constructor for the head of a stream pipeline.
174 *
175 * @param source {@code Spliterator} describing the stream source
176 * @param sourceFlags the source flags for the stream source, described in
177 * {@link StreamOpFlag}
178 * @param parallel {@code true} if the pipeline is parallel
179 */
180 AbstractPipeline(Spliterator<?> source,
181 int sourceFlags, boolean parallel) {
182 this.previousStage = null;
183 this.sourceSpliterator = source;
184 this.sourceStage = this;
185 this.sourceOrOpFlags = sourceFlags & StreamOpFlag.STREAM_MASK;
186 // The following is an optimization of:
187 // StreamOpFlag.combineOpFlags(sourceOrOpFlags, StreamOpFlag.INITIAL_OPS_VALUE);
188 this.combinedFlags = (~(sourceOrOpFlags << 1)) & StreamOpFlag.INITIAL_OPS_VALUE;
189 this.depth = 0;
190 this.parallel = parallel;
191 }
192
193 /**
194 * Constructor for appending an intermediate operation stage onto an
195 * existing pipeline.
196 *
197 * @param previousStage the upstream pipeline stage
198 * @param opFlags the operation flags for the new stage, described in
199 * {@link StreamOpFlag}
200 */
201 AbstractPipeline(AbstractPipeline<?, E_IN, ?> previousStage, int opFlags) {
202 if (previousStage.linkedOrConsumed)
203 throw new IllegalStateException(MSG_STREAM_LINKED);
204 previousStage.linkedOrConsumed = true;
205 previousStage.nextStage = this;
206
207 this.previousStage = previousStage;
208 this.sourceOrOpFlags = opFlags & StreamOpFlag.OP_MASK;
209 this.combinedFlags = StreamOpFlag.combineOpFlags(opFlags, previousStage.combinedFlags);
210 this.sourceStage = previousStage.sourceStage;
211 if (opIsStateful())
212 sourceStage.sourceAnyStateful = true;
213 this.depth = previousStage.depth + 1;
214 }
215
216
217 // Terminal evaluation methods
218
219 /**
220 * Evaluate the pipeline with a terminal operation to produce a result.
221 *
222 * @param <R> the type of result
223 * @param terminalOp the terminal operation to be applied to the pipeline.
224 * @return the result
225 */
226 final <R> R evaluate(TerminalOp<E_OUT, R> terminalOp) {
227 assert getOutputShape() == terminalOp.inputShape();
228 if (linkedOrConsumed)
229 throw new IllegalStateException(MSG_STREAM_LINKED);
230 linkedOrConsumed = true;
231
232 return isParallel()
233 ? terminalOp.evaluateParallel(this, sourceSpliterator(terminalOp.getOpFlags()))
234 : terminalOp.evaluateSequential(this, sourceSpliterator(terminalOp.getOpFlags()));
235 }
236
237 /**
238 * Collect the elements output from the pipeline stage.
239 *
240 * @param generator the array generator to be used to create array instances
241 * @return a flat array-backed Node that holds the collected output elements
242 */
243 @SuppressWarnings("unchecked")
244 final Node<E_OUT> evaluateToArrayNode(IntFunction<E_OUT[]> generator) {
245 if (linkedOrConsumed)
246 throw new IllegalStateException(MSG_STREAM_LINKED);
247 linkedOrConsumed = true;
248
249 // If the last intermediate operation is stateful then
250 // evaluate directly to avoid an extra collection step
251 if (isParallel() && previousStage != null && opIsStateful()) {
252 // Set the depth of this, last, pipeline stage to zero to slice the
253 // pipeline such that this operation will not be included in the
254 // upstream slice and upstream operations will not be included
255 // in this slice
256 depth = 0;
257 return opEvaluateParallel(previousStage, previousStage.sourceSpliterator(0), generator);
258 }
259 else {
260 return evaluate(sourceSpliterator(0), true, generator);
261 }
262 }
263
264 /**
265 * Gets the source stage spliterator if this pipeline stage is the source
266 * stage. The pipeline is consumed after this method is called and
267 * returns successfully.
268 *
269 * @return the source stage spliterator
270 * @throws IllegalStateException if this pipeline stage is not the source
271 * stage.
272 */
273 @SuppressWarnings("unchecked")
274 final Spliterator<E_OUT> sourceStageSpliterator() {
275 if (this != sourceStage)
276 throw new IllegalStateException();
277
278 if (linkedOrConsumed)
279 throw new IllegalStateException(MSG_STREAM_LINKED);
280 linkedOrConsumed = true;
281
282 if (sourceStage.sourceSpliterator != null) {
283 @SuppressWarnings("unchecked")
284 Spliterator<E_OUT> s = sourceStage.sourceSpliterator;
285 sourceStage.sourceSpliterator = null;
286 return s;
287 }
288 else if (sourceStage.sourceSupplier != null) {
289 @SuppressWarnings("unchecked")
290 Spliterator<E_OUT> s = (Spliterator<E_OUT>) sourceStage.sourceSupplier.get();
291 sourceStage.sourceSupplier = null;
292 return s;
293 }
294 else {
295 throw new IllegalStateException(MSG_CONSUMED);
296 }
297 }
298
299 // BaseStream
300
301 @Override
302 @SuppressWarnings("unchecked")
303 public final S sequential() {
304 sourceStage.parallel = false;
305 return (S) this;
306 }
307
308 @Override
309 @SuppressWarnings("unchecked")
310 public final S parallel() {
311 sourceStage.parallel = true;
312 return (S) this;
313 }
314
315 @Override
316 public void close() {
317 linkedOrConsumed = true;
318 sourceSupplier = null;
319 sourceSpliterator = null;
320 if (sourceStage.sourceCloseAction != null) {
321 Runnable closeAction = sourceStage.sourceCloseAction;
322 sourceStage.sourceCloseAction = null;
323 closeAction.run();
324 }
325 }
326
327 @Override
328 @SuppressWarnings("unchecked")
329 public S onClose(Runnable closeHandler) {
330 Objects.requireNonNull(closeHandler);
331 Runnable existingHandler = sourceStage.sourceCloseAction;
332 sourceStage.sourceCloseAction =
333 (existingHandler == null)
334 ? closeHandler
335 : Streams.composeWithExceptions(existingHandler, closeHandler);
336 return (S) this;
337 }
338
339 // Primitive specialization use co-variant overrides, hence is not final
340 @Override
341 @SuppressWarnings("unchecked")
342 public Spliterator<E_OUT> spliterator() {
343 if (linkedOrConsumed)
344 throw new IllegalStateException(MSG_STREAM_LINKED);
345 linkedOrConsumed = true;
346
347 if (this == sourceStage) {
348 if (sourceStage.sourceSpliterator != null) {
349 @SuppressWarnings("unchecked")
350 Spliterator<E_OUT> s = (Spliterator<E_OUT>) sourceStage.sourceSpliterator;
351 sourceStage.sourceSpliterator = null;
352 return s;
353 }
354 else if (sourceStage.sourceSupplier != null) {
355 @SuppressWarnings("unchecked")
356 Supplier<Spliterator<E_OUT>> s = (Supplier<Spliterator<E_OUT>>) sourceStage.sourceSupplier;
357 sourceStage.sourceSupplier = null;
358 return lazySpliterator(s);
359 }
360 else {
361 throw new IllegalStateException(MSG_CONSUMED);
362 }
363 }
364 else {
365 return wrap(this, () -> sourceSpliterator(0), isParallel());
366 }
367 }
368
369 @Override
370 public final boolean isParallel() {
371 return sourceStage.parallel;
372 }
373
374
375 /**
376 * Returns the composition of stream flags of the stream source and all
377 * intermediate operations.
378 *
379 * @return the composition of stream flags of the stream source and all
380 * intermediate operations
381 * @see StreamOpFlag
382 */
383 final int getStreamFlags() {
384 return StreamOpFlag.toStreamFlags(combinedFlags);
385 }
386
387 /**
388 * Get the source spliterator for this pipeline stage. For a sequential or
389 * stateless parallel pipeline, this is the source spliterator. For a
390 * stateful parallel pipeline, this is a spliterator describing the results
391 * of all computations up to and including the most recent stateful
392 * operation.
393 */
394 @SuppressWarnings("unchecked")
395 private Spliterator<?> sourceSpliterator(int terminalFlags) {
396 // Get the source spliterator of the pipeline
397 Spliterator<?> spliterator = null;
398 if (sourceStage.sourceSpliterator != null) {
399 spliterator = sourceStage.sourceSpliterator;
400 sourceStage.sourceSpliterator = null;
401 }
402 else if (sourceStage.sourceSupplier != null) {
403 spliterator = (Spliterator<?>) sourceStage.sourceSupplier.get();
404 sourceStage.sourceSupplier = null;
405 }
406 else {
407 throw new IllegalStateException(MSG_CONSUMED);
408 }
409
410 if (isParallel() && sourceStage.sourceAnyStateful) {
411 // Adapt the source spliterator, evaluating each stateful op
412 // in the pipeline up to and including this pipeline stage.
413 // The depth and flags of each pipeline stage are adjusted accordingly.
414 int depth = 1;
415 for (@SuppressWarnings("rawtypes") AbstractPipeline u = sourceStage, p = sourceStage.nextStage, e = this;
416 u != e;
417 u = p, p = p.nextStage) {
418
419 int thisOpFlags = p.sourceOrOpFlags;
420 if (p.opIsStateful()) {
421 depth = 0;
422
423 if (StreamOpFlag.SHORT_CIRCUIT.isKnown(thisOpFlags)) {
424 // Clear the short circuit flag for next pipeline stage
425 // This stage encapsulates short-circuiting, the next
426 // stage may not have any short-circuit operations, and
427 // if so spliterator.forEachRemaining should be used
428 // for traversal
429 thisOpFlags = thisOpFlags & ~StreamOpFlag.IS_SHORT_CIRCUIT;
430 }
431
432 spliterator = p.opEvaluateParallelLazy(u, spliterator);
433
434 // Inject or clear SIZED on the source pipeline stage
435 // based on the stage's spliterator
436 thisOpFlags = spliterator.hasCharacteristics(Spliterator.SIZED)
437 ? (thisOpFlags & ~StreamOpFlag.NOT_SIZED) | StreamOpFlag.IS_SIZED
438 : (thisOpFlags & ~StreamOpFlag.IS_SIZED) | StreamOpFlag.NOT_SIZED;
439 }
440 p.depth = depth++;
441 p.combinedFlags = StreamOpFlag.combineOpFlags(thisOpFlags, u.combinedFlags);
442 }
443 }
444
445 if (terminalFlags != 0) {
446 // Apply flags from the terminal operation to last pipeline stage
447 combinedFlags = StreamOpFlag.combineOpFlags(terminalFlags, combinedFlags);
448 }
449
450 return spliterator;
451 }
452
453 // PipelineHelper
454
455 @Override
456 final StreamShape getSourceShape() {
457 @SuppressWarnings("rawtypes")
458 AbstractPipeline p = AbstractPipeline.this;
459 while (p.depth > 0) {
460 p = p.previousStage;
461 }
462 return p.getOutputShape();
463 }
464
465 @Override
466 final <P_IN> long exactOutputSizeIfKnown(Spliterator<P_IN> spliterator) {
467 return StreamOpFlag.SIZED.isKnown(getStreamAndOpFlags()) ? spliterator.getExactSizeIfKnown() : -1;
468 }
469
470 @Override
471 final <P_IN, S extends Sink<E_OUT>> S wrapAndCopyInto(S sink, Spliterator<P_IN> spliterator) {
472 copyInto(wrapSink(Objects.requireNonNull(sink)), spliterator);
473 return sink;
474 }
475
476 @Override
477 final <P_IN> void copyInto(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator) {
478 Objects.requireNonNull(wrappedSink);
479
480 if (!StreamOpFlag.SHORT_CIRCUIT.isKnown(getStreamAndOpFlags())) {
481 wrappedSink.begin(spliterator.getExactSizeIfKnown());
482 spliterator.forEachRemaining(wrappedSink);
483 wrappedSink.end();
484 }
485 else {
486 copyIntoWithCancel(wrappedSink, spliterator);
487 }
488 }
489
490 @Override
491 @SuppressWarnings("unchecked")
492 final <P_IN> boolean copyIntoWithCancel(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator) {
493 @SuppressWarnings({"rawtypes","unchecked"})
494 AbstractPipeline p = AbstractPipeline.this;
495 while (p.depth > 0) {
496 p = p.previousStage;
497 }
498
499 wrappedSink.begin(spliterator.getExactSizeIfKnown());
500 boolean cancelled = p.forEachWithCancel(spliterator, wrappedSink);
501 wrappedSink.end();
502 return cancelled;
503 }
504
505 @Override
506 final int getStreamAndOpFlags() {
507 return combinedFlags;
508 }
509
510 final boolean isOrdered() {
511 return StreamOpFlag.ORDERED.isKnown(combinedFlags);
512 }
513
514 @Override
515 @SuppressWarnings("unchecked")
516 final <P_IN> Sink<P_IN> wrapSink(Sink<E_OUT> sink) {
517 Objects.requireNonNull(sink);
518
519 for ( @SuppressWarnings("rawtypes") AbstractPipeline p=AbstractPipeline.this; p.depth > 0; p=p.previousStage) {
520 sink = p.opWrapSink(p.previousStage.combinedFlags, sink);
521 }
522 return (Sink<P_IN>) sink;
523 }
524
525 @Override
526 @SuppressWarnings("unchecked")
527 final <P_IN> Spliterator<E_OUT> wrapSpliterator(Spliterator<P_IN> sourceSpliterator) {
528 if (depth == 0) {
529 return (Spliterator<E_OUT>) sourceSpliterator;
530 }
531 else {
532 return wrap(this, () -> sourceSpliterator, isParallel());
533 }
534 }
535
536 @Override
537 @SuppressWarnings("unchecked")
538 final <P_IN> Node<E_OUT> evaluate(Spliterator<P_IN> spliterator,
539 boolean flatten,
540 IntFunction<E_OUT[]> generator) {
541 if (isParallel()) {
542 // @@@ Optimize if op of this pipeline stage is a stateful op
543 return evaluateToNode(this, spliterator, flatten, generator);
544 }
545 else {
546 Node.Builder<E_OUT> nb = makeNodeBuilder(
547 exactOutputSizeIfKnown(spliterator), generator);
548 return wrapAndCopyInto(nb, spliterator).build();
549 }
550 }
551
552
553 // Shape-specific abstract methods, implemented by XxxPipeline classes
554
555 /**
556 * Get the output shape of the pipeline. If the pipeline is the head,
557 * then it's output shape corresponds to the shape of the source.
558 * Otherwise, it's output shape corresponds to the output shape of the
559 * associated operation.
560 *
561 * @return the output shape
562 */
563 abstract StreamShape getOutputShape();
564
565 /**
566 * Collect elements output from a pipeline into a Node that holds elements
567 * of this shape.
568 *
569 * @param helper the pipeline helper describing the pipeline stages
570 * @param spliterator the source spliterator
571 * @param flattenTree true if the returned node should be flattened
572 * @param generator the array generator
573 * @return a Node holding the output of the pipeline
574 */
575 abstract <P_IN> Node<E_OUT> evaluateToNode(PipelineHelper<E_OUT> helper,
576 Spliterator<P_IN> spliterator,
577 boolean flattenTree,
578 IntFunction<E_OUT[]> generator);
579
580 /**
581 * Create a spliterator that wraps a source spliterator, compatible with
582 * this stream shape, and operations associated with a {@link
583 * PipelineHelper}.
584 *
585 * @param ph the pipeline helper describing the pipeline stages
586 * @param supplier the supplier of a spliterator
587 * @return a wrapping spliterator compatible with this shape
588 */
589 abstract <P_IN> Spliterator<E_OUT> wrap(PipelineHelper<E_OUT> ph,
590 Supplier<Spliterator<P_IN>> supplier,
591 boolean isParallel);
592
593 /**
594 * Create a lazy spliterator that wraps and obtains the supplied the
595 * spliterator when a method is invoked on the lazy spliterator.
596 * @param supplier the supplier of a spliterator
597 */
598 abstract Spliterator<E_OUT> lazySpliterator(Supplier<? extends Spliterator<E_OUT>> supplier);
599
600 /**
601 * Traverse the elements of a spliterator compatible with this stream shape,
602 * pushing those elements into a sink. If the sink requests cancellation,
603 * no further elements will be pulled or pushed.
604 *
605 * @param spliterator the spliterator to pull elements from
606 * @param sink the sink to push elements to
607 * @return true if the cancellation was requested
608 */
609 abstract boolean forEachWithCancel(Spliterator<E_OUT> spliterator, Sink<E_OUT> sink);
610
611 /**
612 * Make a node builder compatible with this stream shape.
613 *
614 * @param exactSizeIfKnown if {@literal >=0}, then a node builder will be
615 * created that has a fixed capacity of at most sizeIfKnown elements. If
616 * {@literal < 0}, then the node builder has an unfixed capacity. A fixed
617 * capacity node builder will throw exceptions if an element is added after
618 * builder has reached capacity, or is built before the builder has reached
619 * capacity.
620 *
621 * @param generator the array generator to be used to create instances of a
622 * T[] array. For implementations supporting primitive nodes, this parameter
623 * may be ignored.
624 * @return a node builder
625 */
626 @Override
627 abstract Node.Builder<E_OUT> makeNodeBuilder(long exactSizeIfKnown,
628 IntFunction<E_OUT[]> generator);
629
630
631 // Op-specific abstract methods, implemented by the operation class
632
633 /**
634 * Returns whether this operation is stateful or not. If it is stateful,
635 * then the method
636 * {@link #opEvaluateParallel(PipelineHelper, java.util.Spliterator, java.util.function.IntFunction)}
637 * must be overridden.
638 *
639 * @return {@code true} if this operation is stateful
640 */
641 abstract boolean opIsStateful();
642
643 /**
644 * Accepts a {@code Sink} which will receive the results of this operation,
645 * and return a {@code Sink} which accepts elements of the input type of
646 * this operation and which performs the operation, passing the results to
647 * the provided {@code Sink}.
648 *
649 * @apiNote
650 * The implementation may use the {@code flags} parameter to optimize the
651 * sink wrapping. For example, if the input is already {@code DISTINCT},
652 * the implementation for the {@code Stream#distinct()} method could just
653 * return the sink it was passed.
654 *
655 * @param flags The combined stream and operation flags up to, but not
656 * including, this operation
657 * @param sink sink to which elements should be sent after processing
658 * @return a sink which accepts elements, perform the operation upon
659 * each element, and passes the results (if any) to the provided
660 * {@code Sink}.
661 */
662 abstract Sink<E_IN> opWrapSink(int flags, Sink<E_OUT> sink);
663
664 /**
665 * Performs a parallel evaluation of the operation using the specified
666 * {@code PipelineHelper} which describes the upstream intermediate
667 * operations. Only called on stateful operations. If {@link
668 * #opIsStateful()} returns true then implementations must override the
669 * default implementation.
670 *
671 * @implSpec The default implementation always throw
672 * {@code UnsupportedOperationException}.
673 *
674 * @param helper the pipeline helper describing the pipeline stages
675 * @param spliterator the source {@code Spliterator}
676 * @param generator the array generator
677 * @return a {@code Node} describing the result of the evaluation
678 */
679 <P_IN> Node<E_OUT> opEvaluateParallel(PipelineHelper<E_OUT> helper,
680 Spliterator<P_IN> spliterator,
681 IntFunction<E_OUT[]> generator) {
682 throw new UnsupportedOperationException("Parallel evaluation is not supported");
683 }
684
685 /**
686 * Returns a {@code Spliterator} describing a parallel evaluation of the
687 * operation, using the specified {@code PipelineHelper} which describes the
688 * upstream intermediate operations. Only called on stateful operations.
689 * It is not necessary (though acceptable) to do a full computation of the
690 * result here; it is preferable, if possible, to describe the result via a
691 * lazily evaluated spliterator.
692 *
693 * @implSpec The default implementation behaves as if:
694 * <pre>{@code
695 * return evaluateParallel(helper, i -> (E_OUT[]) new
696 * Object[i]).spliterator();
697 * }</pre>
698 * and is suitable for implementations that cannot do better than a full
699 * synchronous evaluation.
700 *
701 * @param helper the pipeline helper
702 * @param spliterator the source {@code Spliterator}
703 * @return a {@code Spliterator} describing the result of the evaluation
704 */
705 @SuppressWarnings("unchecked")
706 <P_IN> Spliterator<E_OUT> opEvaluateParallelLazy(PipelineHelper<E_OUT> helper,
707 Spliterator<P_IN> spliterator) {
708 return opEvaluateParallel(helper, spliterator, i -> (E_OUT[]) new Object[i]).spliterator();
709 }
710 }