/**

private static abstract class AbstractWrappingSpliterator<P_IN, P_OUT,

T_BUFFER extends AbstractSpinedBuffer>

implements Spliterator<P_OUT> {

// @@@ Detect if stateful operations are present or not

// If not then can split otherwise cannot

/**

final boolean isParallel;

final PipelineHelper<P_OUT> ph;

/**

private Supplier<Spliterator<P_IN>> spliteratorSupplier;

/**

Spliterator<P_IN> spliterator;

/**

Sink<P_IN> bufferSink;

/**

BooleanSupplier pusher;

/** Next element to consume from the buffer, used during partial traversal */

long nextToConsume;

/** Buffer into which elements are pushed. Used during partial traversal. */

T_BUFFER buffer;

/**

boolean finished;

/**

AbstractWrappingSpliterator(PipelineHelper<P_OUT> ph,

Supplier<Spliterator<P_IN>> spliteratorSupplier,

boolean parallel) {

this.ph = ph;

this.spliteratorSupplier = spliteratorSupplier;

this.spliterator = null;

this.isParallel = parallel;

}

/**

AbstractWrappingSpliterator(PipelineHelper<P_OUT> ph,

Spliterator<P_IN> spliterator,

boolean parallel) {

this.ph = ph;

this.spliteratorSupplier = null;

this.spliterator = spliterator;

this.isParallel = parallel;

}

/**

final void init() {

if (spliterator == null) {

spliterator = spliteratorSupplier.get();

spliteratorSupplier = null;

}

}

/**

final boolean doAdvance() {

if (buffer == null) {

if (finished)

return false;

init();

initPartialTraversalState();

nextToConsume = 0;

bufferSink.begin(spliterator.getExactSizeIfKnown());

return fillBuffer();

}

else {

++nextToConsume;

boolean hasNext = nextToConsume < buffer.count();

if (!hasNext) {

nextToConsume = 0;

buffer.clear();

hasNext = fillBuffer();

}

return hasNext;

}

}

/**

abstract AbstractWrappingSpliterator<P_IN, P_OUT, ?> wrap(Spliterator<P_IN> s);

/**

abstract void initPartialTraversalState();

@Override

public Spliterator<P_OUT> trySplit() {

if (isParallel && !finished) {

init();

Spliterator<P_IN> split = spliterator.trySplit();

return (split == null) ? null : wrap(split);

}

else

return null;

}

/**

private boolean fillBuffer() {

while (buffer.count() == 0) {

if (bufferSink.cancellationRequested() || !pusher.getAsBoolean()) {

if (finished)

return false;

else {

bufferSink.end(); // might trigger more elements

finished = true;

}

}

}

return true;

}

@Override

public final long estimateSize() {

init();

// Use the estimate of the wrapped spliterator

// Note this may not be accurate if there are filter/flatMap

// operations filtering or adding elements to the stream

return spliterator.estimateSize();

}

@Override

public final long getExactSizeIfKnown() {

init();

return StreamOpFlag.SIZED.isKnown(ph.getStreamAndOpFlags())

? spliterator.getExactSizeIfKnown()

: -1;

}

@Override

public final int characteristics() {

init();

// Get the characteristics from the pipeline

int c = StreamOpFlag.toCharacteristics(StreamOpFlag.toStreamFlags(ph.getStreamAndOpFlags()));

// Mask off the size and uniform characteristics and replace with

// those of the spliterator

// Note that a non-uniform spliterator can change from something

// with an exact size to an estimate for a sub-split, for example

// with HashSet where the size is known at the top level spliterator

// but for sub-splits only an estimate is known

if ((c & Spliterator.SIZED) != 0) {

c &= ~(Spliterator.SIZED | Spliterator.SUBSIZED);

c |= (spliterator.characteristics() & (Spliterator.SIZED | Spliterator.SUBSIZED));

}

return c;

}

@Override

public Comparator<? super P_OUT> getComparator() {

if (!hasCharacteristics(SORTED))

throw new IllegalStateException();

return null;

}

@Override

public final String toString() {

return String.format("%s[%s]", getClass().getName(), spliterator);

}

}

static final class WrappingSpliterator<P_IN, P_OUT>

extends AbstractWrappingSpliterator<P_IN, P_OUT, SpinedBuffer<P_OUT>> {

WrappingSpliterator(PipelineHelper<P_OUT> ph,

Supplier<Spliterator<P_IN>> supplier,

boolean parallel) {

super(ph, supplier, parallel);

}

WrappingSpliterator(PipelineHelper<P_OUT> ph,

Spliterator<P_IN> spliterator,

boolean parallel) {

super(ph, spliterator, parallel);

}

@Override

WrappingSpliterator<P_IN, P_OUT> wrap(Spliterator<P_IN> s) {

return new WrappingSpliterator<>(ph, s, isParallel);

}

@Override

void initPartialTraversalState() {

SpinedBuffer<P_OUT> b = new SpinedBuffer<>();

buffer = b;

bufferSink = ph.wrapSink(b::accept);

pusher = () -> spliterator.tryAdvance(bufferSink);

}

@Override

public boolean tryAdvance(Consumer<? super P_OUT> consumer) {

Objects.requireNonNull(consumer);

boolean hasNext = doAdvance();

if (hasNext)

consumer.accept(buffer.get(nextToConsume));

return hasNext;

}

@Override

public void forEachRemaining(Consumer<? super P_OUT> consumer) {

if (buffer == null && !finished) {

Objects.requireNonNull(consumer);

init();

ph.wrapAndCopyInto((Sink<P_OUT>) consumer::accept, spliterator);

finished = true;

}

else {

do { } while (tryAdvance(consumer));

}

}

}

static final class IntWrappingSpliterator<P_IN>

extends AbstractWrappingSpliterator<P_IN, Integer, SpinedBuffer.OfInt>

implements Spliterator.OfInt {

IntWrappingSpliterator(PipelineHelper<Integer> ph,

Supplier<Spliterator<P_IN>> supplier,

boolean parallel) {

super(ph, supplier, parallel);

}

IntWrappingSpliterator(PipelineHelper<Integer> ph,

Spliterator<P_IN> spliterator,

boolean parallel) {

super(ph, spliterator, parallel);

}

@Override

AbstractWrappingSpliterator<P_IN, Integer, ?> wrap(Spliterator<P_IN> s) {

return new IntWrappingSpliterator<>(ph, s, isParallel);

}

@Override

void initPartialTraversalState() {

SpinedBuffer.OfInt b = new SpinedBuffer.OfInt();

buffer = b;

bufferSink = ph.wrapSink((Sink.OfInt) b::accept);

pusher = () -> spliterator.tryAdvance(bufferSink);

}

@Override

public Spliterator.OfInt trySplit() {

return (Spliterator.OfInt) super.trySplit();

}

@Override

public boolean tryAdvance(IntConsumer consumer) {

Objects.requireNonNull(consumer);

boolean hasNext = doAdvance();

if (hasNext)

consumer.accept(buffer.get(nextToConsume));

return hasNext;

}

@Override

public void forEachRemaining(IntConsumer consumer) {

if (buffer == null && !finished) {

Objects.requireNonNull(consumer);

init();

ph.wrapAndCopyInto((Sink.OfInt) consumer::accept, spliterator);

finished = true;

}

else {

do { } while (tryAdvance(consumer));

}

}

}

static final class LongWrappingSpliterator<P_IN>

extends AbstractWrappingSpliterator<P_IN, Long, SpinedBuffer.OfLong>

implements Spliterator.OfLong {

LongWrappingSpliterator(PipelineHelper<Long> ph,

Supplier<Spliterator<P_IN>> supplier,

boolean parallel) {

super(ph, supplier, parallel);

}

LongWrappingSpliterator(PipelineHelper<Long> ph,

Spliterator<P_IN> spliterator,

boolean parallel) {

super(ph, spliterator, parallel);

}

@Override

AbstractWrappingSpliterator<P_IN, Long, ?> wrap(Spliterator<P_IN> s) {

return new LongWrappingSpliterator<>(ph, s, isParallel);

}

@Override

void initPartialTraversalState() {

SpinedBuffer.OfLong b = new SpinedBuffer.OfLong();

buffer = b;

bufferSink = ph.wrapSink((Sink.OfLong) b::accept);

pusher = () -> spliterator.tryAdvance(bufferSink);

}

@Override

public Spliterator.OfLong trySplit() {

return (Spliterator.OfLong) super.trySplit();

}

@Override

public boolean tryAdvance(LongConsumer consumer) {

Objects.requireNonNull(consumer);

boolean hasNext = doAdvance();

if (hasNext)

consumer.accept(buffer.get(nextToConsume));

return hasNext;

}

@Override

public void forEachRemaining(LongConsumer consumer) {

if (buffer == null && !finished) {

Objects.requireNonNull(consumer);

init();

ph.wrapAndCopyInto((Sink.OfLong) consumer::accept, spliterator);

finished = true;

}

else {

do { } while (tryAdvance(consumer));

}

}

}

static final class DoubleWrappingSpliterator<P_IN>

extends AbstractWrappingSpliterator<P_IN, Double, SpinedBuffer.OfDouble>

implements Spliterator.OfDouble {

DoubleWrappingSpliterator(PipelineHelper<Double> ph,

Supplier<Spliterator<P_IN>> supplier,

boolean parallel) {

super(ph, supplier, parallel);

}

DoubleWrappingSpliterator(PipelineHelper<Double> ph,

Spliterator<P_IN> spliterator,

boolean parallel) {

super(ph, spliterator, parallel);

}

@Override

AbstractWrappingSpliterator<P_IN, Double, ?> wrap(Spliterator<P_IN> s) {

return new DoubleWrappingSpliterator<>(ph, s, isParallel);

}

@Override

void initPartialTraversalState() {

SpinedBuffer.OfDouble b = new SpinedBuffer.OfDouble();

buffer = b;

bufferSink = ph.wrapSink((Sink.OfDouble) b::accept);

pusher = () -> spliterator.tryAdvance(bufferSink);

}

@Override

public Spliterator.OfDouble trySplit() {

return (Spliterator.OfDouble) super.trySplit();

}

@Override

public boolean tryAdvance(DoubleConsumer consumer) {

Objects.requireNonNull(consumer);

boolean hasNext = doAdvance();

if (hasNext)

consumer.accept(buffer.get(nextToConsume));

return hasNext;

}

@Override

public void forEachRemaining(DoubleConsumer consumer) {

if (buffer == null && !finished) {

Objects.requireNonNull(consumer);

init();

ph.wrapAndCopyInto((Sink.OfDouble) consumer::accept, spliterator);

finished = true;

}

else {

do { } while (tryAdvance(consumer));

}

}

}

/**

static class DelegatingSpliterator<T, T_SPLITR extends Spliterator<T>>

implements Spliterator<T> {

private final Supplier<? extends T_SPLITR> supplier;

private T_SPLITR s;

DelegatingSpliterator(Supplier<? extends T_SPLITR> supplier) {

this.supplier = supplier;

}

T_SPLITR get() {

if (s == null) {

s = supplier.get();

}

return s;

}

@Override

public T_SPLITR trySplit() {

return (T_SPLITR) get().trySplit();

}

@Override

public boolean tryAdvance(Consumer<? super T> consumer) {

return get().tryAdvance(consumer);

}

@Override

public void forEachRemaining(Consumer<? super T> consumer) {

get().forEachRemaining(consumer);

}

@Override

public long estimateSize() {

return get().estimateSize();

}

@Override

public int characteristics() {

return get().characteristics();

}

@Override

public Comparator<? super T> getComparator() {

return get().getComparator();

}

@Override

public long getExactSizeIfKnown() {

return get().getExactSizeIfKnown();

}

@Override

public String toString() {

return getClass().getName() + "[" + get() + "]";

}

static class OfPrimitive<T, T_CONS, T_SPLITR extends Spliterator.OfPrimitive<T, T_CONS, T_SPLITR>>

extends DelegatingSpliterator<T, T_SPLITR>

implements Spliterator.OfPrimitive<T, T_CONS, T_SPLITR> {

OfPrimitive(Supplier<? extends T_SPLITR> supplier) {

super(supplier);

}

@Override

public boolean tryAdvance(T_CONS consumer) {

return get().tryAdvance(consumer);

}

@Override

public void forEachRemaining(T_CONS consumer) {

get().forEachRemaining(consumer);

}

}

static final class OfInt

extends OfPrimitive<Integer, IntConsumer, Spliterator.OfInt>

implements Spliterator.OfInt {

OfInt(Supplier<Spliterator.OfInt> supplier) {

super(supplier);

}

}

static final class OfLong

extends OfPrimitive<Long, LongConsumer, Spliterator.OfLong>

implements Spliterator.OfLong {

OfLong(Supplier<Spliterator.OfLong> supplier) {

super(supplier);

}

}

static final class OfDouble

extends OfPrimitive<Double, DoubleConsumer, Spliterator.OfDouble>

implements Spliterator.OfDouble {

OfDouble(Supplier<Spliterator.OfDouble> supplier) {

super(supplier);

}

}

}

/**

static abstract class SliceSpliterator<T, T_SPLITR extends Spliterator<T>> {

// The start index of the slice

final long sliceOrigin;

// One past the last index of the slice

final long sliceFence;

// The spliterator to slice

T_SPLITR s;

// current (absolute) index, modified on advance/split

long index;

// one past last (absolute) index or sliceFence, which ever is smaller

long fence;

SliceSpliterator(T_SPLITR s, long sliceOrigin, long sliceFence, long origin, long fence) {

assert s.hasCharacteristics(Spliterator.SUBSIZED);

this.s = s;

this.sliceOrigin = sliceOrigin;

this.sliceFence = sliceFence;

this.index = origin;

this.fence = fence;

}

protected abstract T_SPLITR makeSpliterator(T_SPLITR s, long sliceOrigin, long sliceFence, long origin, long fence);

public T_SPLITR trySplit() {

if (sliceOrigin >= fence)

return null;

if (index >= fence)

return null;

// Keep splitting until the left and right splits intersect with the slice

// thereby ensuring the size estimate decreases.

// This also avoids creating empty spliterators which can result in

// existing and additionally created F/J tasks that perform

// redundant work on no elements.

while (true) {

T_SPLITR leftSplit = (T_SPLITR) s.trySplit();

if (leftSplit == null)

return null;

long leftSplitFenceUnbounded = index + leftSplit.estimateSize();

long leftSplitFence = Math.min(leftSplitFenceUnbounded, sliceFence);

if (sliceOrigin >= leftSplitFence) {

// The left split does not intersect with, and is to the left of, the slice

// The right split does intersect

// Discard the left split and split further with the right split

index = leftSplitFence;

}

else if (leftSplitFence >= sliceFence) {

// The right split does not intersect with, and is to the right of, the slice

// The left split does intersect

// Discard the right split and split further with the left split

s = leftSplit;

fence = leftSplitFence;

}

else if (index >= sliceOrigin && leftSplitFenceUnbounded <= sliceFence) {

// The left split is contained within the slice, return the underlying left split

// Right split is contained within or intersects with the slice

index = leftSplitFence;

return leftSplit;

} else {

// The left split intersects with the slice

// Right split is contained within or intersects with the slice

return makeSpliterator(leftSplit, sliceOrigin, sliceFence, index, index = leftSplitFence);

}

}

}

public long estimateSize() {

return (sliceOrigin < fence)

? fence - Math.max(sliceOrigin, index) : 0;

}

public int characteristics() {

return s.characteristics();

}

static final class OfRef<T>

extends SliceSpliterator<T, Spliterator<T>>

implements Spliterator<T> {

OfRef(Spliterator<T> s, long sliceOrigin, long sliceFence) {

this(s, sliceOrigin, sliceFence, 0, Math.min(s.estimateSize(), sliceFence));

}

private OfRef(Spliterator<T> s,

long sliceOrigin, long sliceFence, long origin, long fence) {

super(s, sliceOrigin, sliceFence, origin, fence);

}

@Override

protected Spliterator<T> makeSpliterator(Spliterator<T> s,

long sliceOrigin, long sliceFence,

long origin, long fence) {

return new OfRef<>(s, sliceOrigin, sliceFence, origin, fence);

}

@Override

public boolean tryAdvance(Consumer<? super T> action) {

Objects.requireNonNull(action);

if (sliceOrigin >= fence)

return false;

while (sliceOrigin > index) {

s.tryAdvance(e -> {});

index++;

}

if (index >= fence)

return false;

index++;

return s.tryAdvance(action);

}

@Override

public void forEachRemaining(Consumer<? super T> action) {

Objects.requireNonNull(action);

if (sliceOrigin >= fence)

return;

if (index >= fence)

return;

if (index >= sliceOrigin && (index + s.estimateSize()) <= sliceFence) {

// The spliterator is contained within the slice

s.forEachRemaining(action);

index = fence;

} else {

// The spliterator intersects with the slice

while (sliceOrigin > index) {

s.tryAdvance(e -> {});

index++;

}

// Traverse elements up to the fence

for (;index < fence; index++) {

s.tryAdvance(action);

}

}

}

}

static abstract class OfPrimitive<T,

T_SPLITR extends Spliterator.OfPrimitive<T, T_CONS, T_SPLITR>,

T_CONS>

extends SliceSpliterator<T, T_SPLITR>

implements Spliterator.OfPrimitive<T, T_CONS, T_SPLITR> {

OfPrimitive(T_SPLITR s, long sliceOrigin, long sliceFence) {

this(s, sliceOrigin, sliceFence, 0, Math.min(s.estimateSize(), sliceFence));

}

private OfPrimitive(T_SPLITR s,

long sliceOrigin, long sliceFence, long origin, long fence) {

super(s, sliceOrigin, sliceFence, origin, fence);

}

@Override

public boolean tryAdvance(T_CONS action) {

Objects.requireNonNull(action);

if (sliceOrigin >= fence)

return false;

while (sliceOrigin > index) {

s.tryAdvance(emptyConsumer());

index++;

}

if (index >= fence)

return false;

index++;

return s.tryAdvance(action);

}

@Override

public void forEachRemaining(T_CONS action) {

Objects.requireNonNull(action);

if (sliceOrigin >= fence)

return;

if (index >= fence)

return;

if (index >= sliceOrigin && (index + s.estimateSize()) <= sliceFence) {

// The spliterator is contained within the slice

s.forEachRemaining(action);

index = fence;

} else {

// The spliterator intersects with the slice

while (sliceOrigin > index) {

s.tryAdvance(emptyConsumer());

index++;

}

// Traverse elements up to the fence

for (;index < fence; index++) {

s.tryAdvance(action);

}

}

}

protected abstract T_CONS emptyConsumer();

}

static final class OfInt extends OfPrimitive<Integer, Spliterator.OfInt, IntConsumer>

implements Spliterator.OfInt {

OfInt(Spliterator.OfInt s, long sliceOrigin, long sliceFence) {

super(s, sliceOrigin, sliceFence);

}

OfInt(Spliterator.OfInt s,

long sliceOrigin, long sliceFence, long origin, long fence) {

super(s, sliceOrigin, sliceFence, origin, fence);

}

@Override

protected Spliterator.OfInt makeSpliterator(Spliterator.OfInt s,

long sliceOrigin, long sliceFence,

long origin, long fence) {

return new SliceSpliterator.OfInt(s, sliceOrigin, sliceFence, origin, fence);

}

@Override

protected IntConsumer emptyConsumer() {

return e -> {};

}

}

static final class OfLong extends OfPrimitive<Long, Spliterator.OfLong, LongConsumer>

implements Spliterator.OfLong {

OfLong(Spliterator.OfLong s, long sliceOrigin, long sliceFence) {

super(s, sliceOrigin, sliceFence);

}

OfLong(Spliterator.OfLong s,

long sliceOrigin, long sliceFence, long origin, long fence) {

super(s, sliceOrigin, sliceFence, origin, fence);

}

@Override

protected Spliterator.OfLong makeSpliterator(Spliterator.OfLong s,

long sliceOrigin, long sliceFence,

long origin, long fence) {

return new SliceSpliterator.OfLong(s, sliceOrigin, sliceFence, origin, fence);

}

@Override

protected LongConsumer emptyConsumer() {

return e -> {};

}

}

static final class OfDouble extends OfPrimitive<Double, Spliterator.OfDouble, DoubleConsumer>

implements Spliterator.OfDouble {

OfDouble(Spliterator.OfDouble s, long sliceOrigin, long sliceFence) {

super(s, sliceOrigin, sliceFence);

}

OfDouble(Spliterator.OfDouble s,

long sliceOrigin, long sliceFence, long origin, long fence) {

super(s, sliceOrigin, sliceFence, origin, fence);

}

@Override

protected Spliterator.OfDouble makeSpliterator(Spliterator.OfDouble s,

long sliceOrigin, long sliceFence,

long origin, long fence) {

return new SliceSpliterator.OfDouble(s, sliceOrigin, sliceFence, origin, fence);

}

@Override

protected DoubleConsumer emptyConsumer() {

return e -> {};

}

}

}

/**

static abstract class UnorderedSliceSpliterator<T, T_SPLITR extends Spliterator<T>> {

static final int CHUNK_SIZE = 1 << 7;

// The spliterator to slice

protected final T_SPLITR s;

protected final boolean unlimited;

private final long skipThreshold;

private final AtomicLong permits;

UnorderedSliceSpliterator(T_SPLITR s, long skip, long limit) {

this.s = s;

this.unlimited = limit < 0;

this.skipThreshold = limit >= 0 ? limit : 0;

this.permits = new AtomicLong(limit >= 0 ? skip + limit : skip);

}

UnorderedSliceSpliterator(T_SPLITR s,

UnorderedSliceSpliterator<T, T_SPLITR> parent) {

this.s = s;

this.unlimited = parent.unlimited;

this.permits = parent.permits;

this.skipThreshold = parent.skipThreshold;

}

/**

protected final long acquirePermits(long numElements) {

long remainingPermits;

long grabbing;

// permits never increase, and don't decrease below zero

assert numElements > 0;

do {

remainingPermits = permits.get();

if (remainingPermits == 0)

return unlimited ? numElements : 0;

grabbing = Math.min(remainingPermits, numElements);

} while (grabbing > 0 &&

!permits.compareAndSet(remainingPermits, remainingPermits - grabbing));

if (unlimited)

return Math.max(numElements - grabbing, 0);

else if (remainingPermits > skipThreshold)

return Math.max(grabbing - (remainingPermits - skipThreshold), 0);

else

return grabbing;

}

enum PermitStatus { NO_MORE, MAYBE_MORE, UNLIMITED }

/** Call to check if permits might be available before acquiring data */

protected final PermitStatus permitStatus() {

if (permits.get() > 0)

return PermitStatus.MAYBE_MORE;

else

return unlimited ? PermitStatus.UNLIMITED : PermitStatus.NO_MORE;

}

public final T_SPLITR trySplit() {

// Stop splitting when there are no more limit permits

if (permits.get() == 0)

return null;

T_SPLITR split = (T_SPLITR) s.trySplit();

return split == null ? null : makeSpliterator(split);

}

protected abstract T_SPLITR makeSpliterator(T_SPLITR s);

public final long estimateSize() {

return s.estimateSize();

}

public final int characteristics() {

return s.characteristics() &

~(Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED);

}

static final class OfRef<T> extends UnorderedSliceSpliterator<T, Spliterator<T>>

implements Spliterator<T>, Consumer<T> {

T tmpSlot;

OfRef(Spliterator<T> s, long skip, long limit) {

super(s, skip, limit);

}

OfRef(Spliterator<T> s, OfRef<T> parent) {

super(s, parent);

}

@Override