An abstract Spliterator.OfLong that implements trySplit
to permit limited parallelism.

To implement a spliterator an extending class need only
implement tryAdvance. The extending class should override
forEachRemaining
if it can provide a more performant implementation.

API Note:

This class is a useful aid for creating a spliterator when it is not
possible or difficult to efficiently partition elements in a manner
allowing balanced parallel computation.

An alternative to using this class, that also permits limited
parallelism, is to create a spliterator from an iterator
(see Spliterators.spliterator(java.util.PrimitiveIterator.OfLong, long, int).
Depending on the circumstances using an iterator may be easier or more
convenient than extending this class. For example, if there is already an
iterator available to use then there is no need to extend this class.

Method Detail

trySplit

If this spliterator can be partitioned, returns a Spliterator
covering elements, that will, upon return from this method, not
be covered by this Spliterator.

If this Spliterator is Spliterator.ORDERED, the returned Spliterator
must cover a strict prefix of the elements.

Unless this Spliterator covers an infinite number of elements,
repeated calls to trySplit() must eventually return null.
Upon non-null return:

the value reported for estimateSize() before splitting,
must, after splitting, be greater than or equal to estimateSize()
for this and the returned Spliterator; and

if this Spliterator is SUBSIZED, then estimateSize()
for this spliterator before splitting must be equal to the sum of
estimateSize() for this and the returned Spliterator after
splitting.

This method may return null for any reason,
including emptiness, inability to split after traversal has
commenced, data structure constraints, and efficiency
considerations.
This implementation permits limited parallelism.

If this Spliterator is Spliterator.SIZED and has not yet been partially
traversed or split, or this Spliterator is Spliterator.SUBSIZED and has
not yet been partially traversed, this estimate must be an accurate
count of elements that would be encountered by a complete traversal.
Otherwise, this estimate may be arbitrarily inaccurate, but must decrease
as specified across invocations of Spliterator.trySplit().

If a Spliterator reports an inconsistent set of
characteristics (either those returned from a single invocation
or across multiple invocations), no guarantees can be made
about any computation using this Spliterator.