Java Code Examples for java.util.Spliterator#OfInt

@Override
default Node.OfInt truncate(long from, long to, IntFunction<Integer[]> generator) {
    if (from == 0 && to == count())
        return this;
    long size = to - from;
    Spliterator.OfInt spliterator = spliterator();
    Node.Builder.OfInt nodeBuilder = Nodes.intBuilder(size);
    nodeBuilder.begin(size);
    for (int i = 0; i < from && spliterator.tryAdvance((IntConsumer) e -> { }); i++) { }
    if (to == count()) {
        spliterator.forEachRemaining((IntConsumer) nodeBuilder);
    } else {
        for (int i = 0; i < size && spliterator.tryAdvance((IntConsumer) nodeBuilder); i++) { }
    }
    nodeBuilder.end();
    return nodeBuilder.build();
}
 

@Override
default Node.OfInt truncate(long from, long to, IntFunction<Integer[]> generator) {
    if (from == 0 && to == count())
        return this;
    long size = to - from;
    Spliterator.OfInt spliterator = spliterator();
    Node.Builder.OfInt nodeBuilder = Nodes.intBuilder(size);
    nodeBuilder.begin(size);
    for (int i = 0; i < from && spliterator.tryAdvance((IntConsumer) e -> { }); i++) { }
    for (int i = 0; (i < size) && spliterator.tryAdvance((IntConsumer) nodeBuilder); i++) { }
    nodeBuilder.end();
    return nodeBuilder.build();
}
 

protected IntTestData(String name,
                      I state,
                      Function<I, IntStream> streamFn,
                      Function<I, IntStream> parStreamFn,
                      Function<I, Spliterator.OfInt> splitrFn,
                      ToIntFunction<I> sizeFn) {
    super(name, StreamShape.INT_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

@Test(dataProvider = "Spliterator.OfInt")
public void testIntNullPointerException(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
    executeAndCatch(NullPointerException.class, () -> s.get().forEachRemaining((IntConsumer) null));
    executeAndCatch(NullPointerException.class, () -> s.get().tryAdvance((IntConsumer) null));
}
 

@Override
@SuppressWarnings("unchecked")
final Spliterator.OfInt lazySpliterator(Supplier<? extends Spliterator<Integer>> supplier) {
    return new StreamSpliterators.DelegatingSpliterator.OfInt((Supplier<Spliterator.OfInt>) supplier);
}
 

@Override
Spliterator.OfInt spliterator();
 

void add(String description, Supplier<Spliterator.OfInt> s) {
    add(description, exp, s);
}
 

private OfInt(Spliterator.OfInt sp, boolean proxyEstimateSize) {
    super(sp, proxyEstimateSize);
    this.psp = sp;
}
 

@Override
final void forEachWithCancel(Spliterator<Integer> spliterator, Sink<Integer> sink) {
    Spliterator.OfInt spl = adapt(spliterator);
    IntConsumer adaptedSink = adapt(sink);
    do { } while (!sink.cancellationRequested() && spl.tryAdvance(adaptedSink));
}
 

@Override
public Spliterator.OfInt spliterator() {
    return Arrays.spliterator(array, 0, curSize);
}
 

@Test(dataProvider = "Spliterator.OfInt")
public void testIntSplitOnce(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
    testSplitOnce(exp, s, intBoxingConsumer());
}
 

@Override
public final Spliterator.OfInt spliterator() {
    return adapt(super.spliterator());
}
 

@Override
public Spliterator.OfInt spliterator() {
    return Spliterators.emptyIntSpliterator();
}
 

OfInt(Spliterator.OfInt s, long skip, long limit) {
    super(s, skip, limit);
}
 

OfInt(Supplier<Spliterator.OfInt> supplier) {
    super(supplier);
}
 

OfInt(Spliterator.OfInt s, UnorderedSliceSpliterator.OfInt parent) {
    super(s, parent);
}
 

@Test(dataProvider = "Spliterator.OfInt")
public void testIntForEach(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
    testForEach(exp, s, intBoxingConsumer());
}
 

@Test(dataProvider = "Spliterator.OfInt")
public void testIntSplitUntilNull(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
    testSplitUntilNull(exp, s, intBoxingConsumer());
}
 

OfInt(Spliterator.OfInt aSpliterator, Spliterator.OfInt bSpliterator) {
    super(aSpliterator, bSpliterator);
}
 

/**
 * Creates a lazily concatenated stream whose elements are all the
 * elements of the first stream followed by all the elements of the
 * second stream.  The resulting stream is ordered if both
 * of the input streams are ordered, and parallel if either of the input
 * streams is parallel.  When the resulting stream is closed, the close
 * handlers for both input streams are invoked.
 *
 * @implNote
 * Use caution when constructing streams from repeated concatenation.
 * Accessing an element of a deeply concatenated stream can result in deep
 * call chains, or even {@code StackOverflowException}.
 *
 * @param a the first stream
 * @param b the second stream
 * @return the concatenation of the two input streams
 */
public static IntStream concat(IntStream a, IntStream b) {
    Objects.requireNonNull(a);
    Objects.requireNonNull(b);

    Spliterator.OfInt split = new Streams.ConcatSpliterator.OfInt(
            a.spliterator(), b.spliterator());
    IntStream stream = StreamSupport.intStream(split, a.isParallel() || b.isParallel());
    return stream.onClose(Streams.composedClose(a, b));
}