com.landawn.abacus.util.stream.ParallelArrayStream Maven / Gradle / Ivy
/*
* Copyright (C) 2016, 2017, 2018, 2019 HaiYang Li
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.landawn.abacus.util.stream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Deque;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicLong;
import com.landawn.abacus.util.AsyncExecutor;
import com.landawn.abacus.util.ByteIterator;
import com.landawn.abacus.util.CharIterator;
import com.landawn.abacus.util.ContinuableFuture;
import com.landawn.abacus.util.DoubleIterator;
import com.landawn.abacus.util.FloatIterator;
import com.landawn.abacus.util.Fn.Suppliers;
import com.landawn.abacus.util.IntIterator;
import com.landawn.abacus.util.LongIterator;
import com.landawn.abacus.util.Multimap;
import com.landawn.abacus.util.Multiset;
import com.landawn.abacus.util.MutableBoolean;
import com.landawn.abacus.util.MutableInt;
import com.landawn.abacus.util.N;
import com.landawn.abacus.util.Nth;
import com.landawn.abacus.util.ObjIterator;
import com.landawn.abacus.util.Pair;
import com.landawn.abacus.util.ShortIterator;
import com.landawn.abacus.util.Try;
import com.landawn.abacus.util.u.Holder;
import com.landawn.abacus.util.u.Optional;
import com.landawn.abacus.util.function.BiConsumer;
import com.landawn.abacus.util.function.BiFunction;
import com.landawn.abacus.util.function.BinaryOperator;
import com.landawn.abacus.util.function.Consumer;
import com.landawn.abacus.util.function.Function;
import com.landawn.abacus.util.function.Predicate;
import com.landawn.abacus.util.function.Supplier;
import com.landawn.abacus.util.function.ToByteFunction;
import com.landawn.abacus.util.function.ToCharFunction;
import com.landawn.abacus.util.function.ToDoubleFunction;
import com.landawn.abacus.util.function.ToFloatFunction;
import com.landawn.abacus.util.function.ToIntFunction;
import com.landawn.abacus.util.function.ToLongFunction;
import com.landawn.abacus.util.function.ToShortFunction;
import com.landawn.abacus.util.function.TriFunction;
/**
*
*/
final class ParallelArrayStream extends ArrayStream {
private final int maxThreadNum;
private final Splitor splitor;
private final AsyncExecutor asyncExecutor;
private volatile ArrayStream sequential;
ParallelArrayStream(final T[] values, final int fromIndex, final int toIndex, final boolean sorted, Comparator comparator,
final int maxThreadNum, final Splitor splitor, final AsyncExecutor asyncExector, final Collection closeHandlers) {
super(values, fromIndex, toIndex, sorted, comparator, closeHandlers);
this.maxThreadNum = checkMaxThreadNum(maxThreadNum);
this.splitor = splitor == null ? DEFAULT_SPLITOR : splitor;
this.asyncExecutor = asyncExector == null ? DEFAULT_ASYNC_EXECUTOR : asyncExector;
}
@Override
public Stream filter(final Predicate predicate) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.filter(predicate);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
private T next = null;
private boolean hasNext = false;
@Override
public boolean hasNext() {
if (hasNext == false) {
while (cursor < to) {
next = elements[cursor++];
if (predicate.test(next)) {
hasNext = true;
break;
}
}
}
return hasNext;
}
@Override
public T next() {
if (hasNext == false && hasNext() == false) {
throw new NoSuchElementException();
}
hasNext = false;
return next;
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private T next = null;
private boolean hasNext = false;
@Override
public boolean hasNext() {
if (hasNext == false) {
while (true) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
if (predicate.test(next)) {
hasNext = true;
break;
}
}
}
return hasNext;
}
@Override
public T next() {
if (hasNext == false && hasNext() == false) {
throw new NoSuchElementException();
}
hasNext = false;
return next;
}
});
}
}
return new ParallelIteratorStream<>(Stream.parallelConcatt(iters, iters.size()), false, null, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public Stream takeWhile(final Predicate predicate) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.takeWhile(predicate);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
final MutableBoolean hasMore = MutableBoolean.of(true);
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private T next = null;
private boolean hasNext = false;
@Override
public boolean hasNext() {
if (hasNext == false && hasMore.isTrue()) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
hasNext = true;
} else {
hasMore.setFalse();
}
}
if (hasNext && predicate.test(next) == false) {
hasNext = false;
hasMore.setFalse();
}
}
return hasNext;
}
@Override
public T next() {
if (hasNext == false && hasNext() == false) {
throw new NoSuchElementException();
}
hasNext = false;
return next;
}
});
}
return new ParallelIteratorStream<>(Stream.parallelConcatt(iters, iters.size()), false, null, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public Stream dropWhile(final Predicate predicate) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.dropWhile(predicate);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
final MutableBoolean dropped = MutableBoolean.of(false);
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private T next = null;
private boolean hasNext = false;
@Override
public boolean hasNext() {
if (hasNext == false) {
// Only one thread is kept for running after it's dropped.
if (dropped.isTrue()) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
hasNext = true;
}
}
} else {
while (dropped.isFalse()) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
if (predicate.test(next) == false) {
hasNext = true;
dropped.setTrue();
break;
}
}
if (hasNext == false && dropped.isTrue()) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
hasNext = true;
}
}
}
}
}
return hasNext;
}
@Override
public T next() {
if (hasNext == false && hasNext() == false) {
throw new NoSuchElementException();
}
hasNext = false;
return next;
}
});
}
return new ParallelIteratorStream<>(Stream.parallelConcatt(iters, iters.size()), false, null, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public Stream map(final Function mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.map(mapper);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
@Override
public boolean hasNext() {
return cursor < to;
}
@Override
public R next() {
if (cursor >= to) {
throw new NoSuchElementException();
}
return mapper.apply(elements[cursor++]);
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
}
}
}
return next != NONE;
}
@Override
public R next() {
if (next == NONE && hasNext() == false) {
throw new NoSuchElementException();
}
R result = mapper.apply((T) next);
next = NONE;
return result;
}
});
}
}
return new ParallelIteratorStream<>(Stream.parallelConcatt(iters, iters.size()), false, null, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public Stream slidingMap(final BiFunction mapper, final int increment, final boolean ignoreNotPaired) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorStream<>(sequential().slidingMap(mapper, increment).iterator(), false, null, maxThreadNum, splitor, asyncExecutor,
closeHandlers);
}
final int windowSize = 2;
checkArgPositive(increment, "increment");
final List> iters = new ArrayList<>(maxThreadNum);
final MutableInt curIndex = MutableInt.of(fromIndex);
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
private int cursor = -1;
@Override
public boolean hasNext() {
if (cursor == -1) {
synchronized (elements) {
if (ignoreNotPaired ? toIndex - curIndex.intValue() >= windowSize : curIndex.intValue() < toIndex) {
cursor = curIndex.value();
curIndex.setValue(increment < toIndex - cursor && windowSize < toIndex - cursor ? cursor + increment : toIndex);
}
}
}
return cursor != -1;
}
@Override
public R next() {
if (cursor == -1 && hasNext() == false) {
throw new NoSuchElementException();
}
final R result = mapper.apply(elements[cursor], cursor < toIndex - 1 ? elements[cursor + 1] : null);
cursor = -1;
return result;
}
});
}
return new ParallelIteratorStream<>(Stream.parallelConcatt(iters, iters.size()), false, null, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public Stream slidingMap(final TriFunction mapper, final int increment, final boolean ignoreNotPaired) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorStream<>(sequential().slidingMap(mapper, increment).iterator(), false, null, maxThreadNum, splitor, asyncExecutor,
closeHandlers);
}
final int windowSize = 3;
checkArgPositive(increment, "increment");
final List> iters = new ArrayList<>(maxThreadNum);
final MutableInt curIndex = MutableInt.of(fromIndex);
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
private int cursor = -1;
@Override
public boolean hasNext() {
if (cursor == -1) {
synchronized (elements) {
if (ignoreNotPaired ? toIndex - curIndex.intValue() >= windowSize : curIndex.intValue() < toIndex) {
cursor = curIndex.value();
curIndex.setValue(increment < toIndex - cursor && windowSize < toIndex - cursor ? cursor + increment : toIndex);
}
}
}
return cursor != -1;
}
@Override
public R next() {
if (cursor == -1 && hasNext() == false) {
throw new NoSuchElementException();
}
final R result = mapper.apply(elements[cursor], cursor < toIndex - 1 ? elements[cursor + 1] : null,
cursor < toIndex - 2 ? elements[cursor + 2] : null);
cursor = -1;
return result;
}
});
}
return new ParallelIteratorStream<>(Stream.parallelConcatt(iters, iters.size()), false, null, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public Stream mapFirstOrElse(final Function mapperForFirst, final Function mapperForElse) {
checkArgNotNull(mapperForFirst);
checkArgNotNull(mapperForElse);
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.mapFirstOrElse(mapperForFirst, mapperForElse);
}
if (fromIndex == toIndex) {
return (Stream) this;
} else if (toIndex - fromIndex == 1) {
return map(mapperForFirst);
} else {
final Function mapperForFirst2 = (Function) mapperForFirst;
final Function mapperForElse2 = (Function) mapperForElse;
return skip(1).map(mapperForElse2).prepend(Stream.of(elements[fromIndex]).map(mapperForFirst2));
}
}
@Override
public Stream mapLastOrElse(final Function mapperForLast, final Function mapperForElse) {
checkArgNotNull(mapperForLast);
checkArgNotNull(mapperForElse);
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorStream<>(sequential().mapLastOrElse(mapperForLast, mapperForElse).iterator(), false, null, maxThreadNum, splitor,
asyncExecutor, closeHandlers);
}
if (fromIndex == toIndex) {
return (Stream) this;
} else if (toIndex - fromIndex == 1) {
return map(mapperForLast);
} else {
final Function mapperForLast2 = (Function) mapperForLast;
final Function mapperForElse2 = (Function) mapperForElse;
return limit(toIndex - fromIndex - 1).map(mapperForElse2).append(Stream.of(elements[toIndex - 1]).map(mapperForLast2));
}
}
@Override
public CharStream mapToChar(final ToCharFunction mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.mapToChar(mapper);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
@Override
public boolean hasNext() {
return cursor < to;
}
@Override
public Character next() {
if (cursor >= to) {
throw new NoSuchElementException();
}
return mapper.applyAsChar(elements[cursor++]);
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
}
}
}
return next != NONE;
}
@Override
public Character next() {
if (next == NONE && hasNext() == false) {
throw new NoSuchElementException();
}
Character result = mapper.applyAsChar((T) next);
next = NONE;
return result;
}
});
}
}
return new ParallelIteratorCharStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public ByteStream mapToByte(final ToByteFunction mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.mapToByte(mapper);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
@Override
public boolean hasNext() {
return cursor < to;
}
@Override
public Byte next() {
if (cursor >= to) {
throw new NoSuchElementException();
}
return mapper.applyAsByte(elements[cursor++]);
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
}
}
}
return next != NONE;
}
@Override
public Byte next() {
if (next == NONE && hasNext() == false) {
throw new NoSuchElementException();
}
Byte result = mapper.applyAsByte((T) next);
next = NONE;
return result;
}
});
}
}
return new ParallelIteratorByteStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public ShortStream mapToShort(final ToShortFunction mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.mapToShort(mapper);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
@Override
public boolean hasNext() {
return cursor < to;
}
@Override
public Short next() {
if (cursor >= to) {
throw new NoSuchElementException();
}
return mapper.applyAsShort(elements[cursor++]);
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
}
}
}
return next != NONE;
}
@Override
public Short next() {
if (next == NONE && hasNext() == false) {
throw new NoSuchElementException();
}
Short result = mapper.applyAsShort((T) next);
next = NONE;
return result;
}
});
}
}
return new ParallelIteratorShortStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public IntStream mapToInt(final ToIntFunction mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.mapToInt(mapper);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
@Override
public boolean hasNext() {
return cursor < to;
}
@Override
public Integer next() {
if (cursor >= to) {
throw new NoSuchElementException();
}
return mapper.applyAsInt(elements[cursor++]);
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
}
}
}
return next != NONE;
}
@Override
public Integer next() {
if (next == NONE && hasNext() == false) {
throw new NoSuchElementException();
}
Integer result = mapper.applyAsInt((T) next);
next = NONE;
return result;
}
});
}
}
return new ParallelIteratorIntStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public LongStream mapToLong(final ToLongFunction mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.mapToLong(mapper);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
@Override
public boolean hasNext() {
return cursor < to;
}
@Override
public Long next() {
if (cursor >= to) {
throw new NoSuchElementException();
}
return mapper.applyAsLong(elements[cursor++]);
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
}
}
}
return next != NONE;
}
@Override
public Long next() {
if (next == NONE && hasNext() == false) {
throw new NoSuchElementException();
}
Long result = mapper.applyAsLong((T) next);
next = NONE;
return result;
}
});
}
}
return new ParallelIteratorLongStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public FloatStream mapToFloat(final ToFloatFunction mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.mapToFloat(mapper);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
@Override
public boolean hasNext() {
return cursor < to;
}
@Override
public Float next() {
if (cursor >= to) {
throw new NoSuchElementException();
}
return mapper.applyAsFloat(elements[cursor++]);
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
}
}
}
return next != NONE;
}
@Override
public Float next() {
if (next == NONE && hasNext() == false) {
throw new NoSuchElementException();
}
Float result = mapper.applyAsFloat((T) next);
next = NONE;
return result;
}
});
}
}
return new ParallelIteratorFloatStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public DoubleStream mapToDouble(final ToDoubleFunction mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.mapToDouble(mapper);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
@Override
public boolean hasNext() {
return cursor < to;
}
@Override
public Double next() {
if (cursor >= to) {
throw new NoSuchElementException();
}
return mapper.applyAsDouble(elements[cursor++]);
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
}
}
}
return next != NONE;
}
@Override
public Double next() {
if (next == NONE && hasNext() == false) {
throw new NoSuchElementException();
}
Double result = mapper.applyAsDouble((T) next);
next = NONE;
return result;
}
});
}
}
return new ParallelIteratorDoubleStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public Stream flatMap(final Function> mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorStream<>(sequential().flatMap(mapper), false, null, maxThreadNum, splitor, asyncExecutor, null);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
private Iterator cur = null;
private Stream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && cursor < to) {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(elements[cursor++]);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public R next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.next();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private T next = null;
private Iterator cur = null;
private Stream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && next != NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
next = (T) NONE;
break;
}
}
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(next);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public R next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.next();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
}
final Deque newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalArrayDeque(1)
: new LocalArrayDeque(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorStream<>(Stream.parallelConcatt(iters, iters.size()), false, null, maxThreadNum, splitor, asyncExecutor, newCloseHandlers);
}
@Override
public CharStream flatMapToChar(final Function mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorCharStream(sequential().flatMapToChar(mapper), false, maxThreadNum, splitor, asyncExecutor, null);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
private CharIterator cur = null;
private CharStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && cursor < to) {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(elements[cursor++]);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Character next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextChar();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private T next = null;
private CharIterator cur = null;
private CharStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && next != NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
next = (T) NONE;
break;
}
}
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(next);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Character next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextChar();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
}
final Deque newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalArrayDeque(1)
: new LocalArrayDeque(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorCharStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, newCloseHandlers);
}
@Override
public ByteStream flatMapToByte(final Function mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorByteStream(sequential().flatMapToByte(mapper), false, maxThreadNum, splitor, asyncExecutor, null);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
private ByteIterator cur = null;
private ByteStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && cursor < to) {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(elements[cursor++]);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Byte next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextByte();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private T next = null;
private ByteIterator cur = null;
private ByteStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && next != NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
next = (T) NONE;
break;
}
}
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(next);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Byte next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextByte();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
}
final Deque newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalArrayDeque(1)
: new LocalArrayDeque(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorByteStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, newCloseHandlers);
}
@Override
public ShortStream flatMapToShort(final Function mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorShortStream(sequential().flatMapToShort(mapper), false, maxThreadNum, splitor, asyncExecutor, null);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
private ShortIterator cur = null;
private ShortStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && cursor < to) {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(elements[cursor++]);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Short next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextShort();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private T next = null;
private ShortIterator cur = null;
private ShortStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && next != NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
next = (T) NONE;
break;
}
}
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(next);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Short next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextShort();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
}
final Deque newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalArrayDeque(1)
: new LocalArrayDeque(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorShortStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, newCloseHandlers);
}
@Override
public IntStream flatMapToInt(final Function mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorIntStream(sequential().flatMapToInt(mapper), false, maxThreadNum, splitor, asyncExecutor, null);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
private IntIterator cur = null;
private IntStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && cursor < to) {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(elements[cursor++]);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Integer next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextInt();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private T next = null;
private IntIterator cur = null;
private IntStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && next != NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
next = (T) NONE;
break;
}
}
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(next);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Integer next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextInt();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
}
final Deque newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalArrayDeque(1)
: new LocalArrayDeque(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorIntStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, newCloseHandlers);
}
@Override
public LongStream flatMapToLong(final Function mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorLongStream(sequential().flatMapToLong(mapper), false, maxThreadNum, splitor, asyncExecutor, null);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
private LongIterator cur = null;
private LongStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && cursor < to) {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(elements[cursor++]);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Long next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextLong();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private T next = null;
private LongIterator cur = null;
private LongStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && next != NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
next = (T) NONE;
break;
}
}
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(next);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Long next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextLong();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
}
final Deque newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalArrayDeque(1)
: new LocalArrayDeque(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorLongStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, newCloseHandlers);
}
@Override
public FloatStream flatMapToFloat(final Function mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorFloatStream(sequential().flatMapToFloat(mapper), false, maxThreadNum, splitor, asyncExecutor, null);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
private FloatIterator cur = null;
private FloatStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && cursor < to) {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(elements[cursor++]);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Float next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextFloat();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private T next = null;
private FloatIterator cur = null;
private FloatStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && next != NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
next = (T) NONE;
break;
}
}
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(next);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Float next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextFloat();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
}
final Deque newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalArrayDeque(1)
: new LocalArrayDeque(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorFloatStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, newCloseHandlers);
}
@Override
public DoubleStream flatMapToDouble(final Function mapper) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorDoubleStream(sequential().flatMapToDouble(mapper), false, maxThreadNum, splitor, asyncExecutor, null);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
private DoubleIterator cur = null;
private DoubleStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && cursor < to) {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(elements[cursor++]);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Double next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextDouble();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private T next = null;
private DoubleIterator cur = null;
private DoubleStream s = null;
private Runnable closeHandle = null;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && next != NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
next = (T) NONE;
break;
}
}
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
s = mapper.apply(next);
if (N.notNullOrEmpty(s.closeHandlers)) {
final Deque tmp = s.closeHandlers;
closeHandle = new Runnable() {
@Override
public void run() {
Stream.close(tmp);
}
};
}
cur = s.iterator();
}
return cur != null && cur.hasNext();
}
@Override
public Double next() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextDouble();
}
@Override
public void close() {
if (closeHandle != null) {
final Runnable tmp = closeHandle;
closeHandle = null;
tmp.run();
}
}
});
}
}
final Deque newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalArrayDeque(1)
: new LocalArrayDeque(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorDoubleStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, asyncExecutor, newCloseHandlers);
}
@Override
public Stream peek(final Consumer action) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.peek(action);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> iters = new ArrayList<>(threadNum);
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
iters.add(new ObjIteratorEx() {
private int cursor = fromIndex + sliceIndex * sliceSize;
private final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
@Override
public boolean hasNext() {
return cursor < to;
}
@Override
public T next() {
if (cursor >= to) {
throw new NoSuchElementException();
}
action.accept(elements[cursor]);
return elements[cursor++];
}
});
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
}
}
}
return next != NONE;
}
@Override
public T next() {
if (next == NONE && hasNext() == false) {
throw new NoSuchElementException();
}
T result = (T) next;
action.accept(result);
next = NONE;
return result;
}
});
}
}
return new ParallelIteratorStream<>(Stream.parallelConcatt(iters, iters.size()), false, null, maxThreadNum, splitor, asyncExecutor, closeHandlers);
}
@Override
public void forEach(final Try.Consumer action, final Try.Runnable onComplete) throws E, E2 {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
super.forEach(action, onComplete);
return;
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
futureList.add(asyncExecutor.execute(new Try.Runnable() {
@Override
public void run() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
try {
while (cursor < to && eHolder.value() == null) {
action.accept(elements[cursor++]);
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Try.Runnable() {
@Override
public void run() {
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
action.accept(next);
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
}
try {
complette(futureList, eHolder, (E) null);
onComplete.run();
} finally {
close();
}
}
@Override
public void forEach(final Try.Function, E> flatMapper,
final Try.BiConsumer action) throws E, E2 {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
super.forEach(flatMapper, action);
return;
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
futureList.add(asyncExecutor.execute(new Try.Runnable() {
@Override
public void run() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
Collection c = null;
try {
while (cursor < to && eHolder.value() == null) {
c = flatMapper.apply(elements[cursor]);
if (N.notNullOrEmpty(c)) {
for (U u : c) {
action.accept(elements[cursor], u);
}
}
cursor++;
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Try.Runnable() {
@Override
public void run() {
Collection c = null;
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
c = flatMapper.apply(next);
if (N.notNullOrEmpty(c)) {
for (U u : c) {
action.accept(next, u);
}
}
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
}
try {
complette(futureList, eHolder, (E) null);
} finally {
close();
}
}
@Override
public void forEach(
final Try.Function, E> flatMapper, final Try.Function, E2> flatMapper2,
final Try.TriConsumer action) throws E, E2, E3 {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
super.forEach(flatMapper, flatMapper2, action);
return;
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
futureList.add(asyncExecutor.execute(new Try.Runnable() {
@Override
public void run() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
Collection c2 = null;
Collection c3 = null;
try {
while (cursor < to && eHolder.value() == null) {
c2 = flatMapper.apply(elements[cursor]);
if (N.notNullOrEmpty(c2)) {
for (T2 t2 : c2) {
c3 = flatMapper2.apply(t2);
if (N.notNullOrEmpty(c3)) {
for (T3 t3 : c3) {
action.accept(elements[cursor], t2, t3);
}
}
}
}
cursor++;
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Try.Runnable() {
@Override
public void run() {
Collection c2 = null;
Collection c3 = null;
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
c2 = flatMapper.apply(next);
if (N.notNullOrEmpty(c2)) {
for (T2 t2 : c2) {
c3 = flatMapper2.apply(t2);
if (N.notNullOrEmpty(c3)) {
for (T3 t3 : c3) {
action.accept(next, t2, t3);
}
}
}
}
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
}
try {
complette(futureList, eHolder, (E) null);
} finally {
close();
}
}
@Override
public void forEachPair(final Try.BiConsumer action, final int increment) throws E {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
super.forEachPair(action, increment);
return;
}
final int windowSize = 2;
checkArgPositive(increment, "increment");
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
final MutableInt curIndex = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Try.Runnable() {
private int cursor = -1;
@Override
public void run() {
try {
while (curIndex.intValue() < toIndex && eHolder.value() == null) {
synchronized (elements) {
if (curIndex.intValue() < toIndex) {
cursor = curIndex.value();
curIndex.setValue(increment < toIndex - cursor && windowSize < toIndex - cursor ? cursor + increment : toIndex);
} else {
break;
}
}
action.accept(elements[cursor], cursor < toIndex - 1 ? elements[cursor + 1] : null);
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
try {
complette(futureList, eHolder, (E) null);
} finally {
close();
}
}
@Override
public void forEachTriple(final Try.TriConsumer action, final int increment) throws E {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
super.forEachTriple(action, increment);
return;
}
final int windowSize = 3;
checkArgPositive(increment, "increment");
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
final MutableInt curIndex = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Try.Runnable() {
private int cursor = -1;
@Override
public void run() {
try {
while (curIndex.intValue() < toIndex && eHolder.value() == null) {
synchronized (elements) {
if (curIndex.intValue() < toIndex) {
cursor = curIndex.value();
curIndex.setValue(increment < toIndex - cursor && windowSize < toIndex - cursor ? cursor + increment : toIndex);
} else {
break;
}
}
action.accept(elements[cursor], cursor < toIndex - 1 ? elements[cursor + 1] : null,
cursor < toIndex - 2 ? elements[cursor + 2] : null);
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
try {
complette(futureList, eHolder, (E) null);
} finally {
close();
}
}
@Override
A[] toArray(A[] a) {
assertNotClosed();
try {
if (a.length < (toIndex - fromIndex)) {
a = N.newArray(a.getClass().getComponentType(), toIndex - fromIndex);
}
N.copy(elements, fromIndex, a, 0, toIndex - fromIndex);
return a;
} finally {
close();
}
}
@Override
public > M toMap(final Function keyMapper, final Function valueMapper,
final BinaryOperator mergeFunction, final Supplier mapFactory) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.toMap(keyMapper, valueMapper, mergeFunction, mapFactory);
}
// return collect(Collectors.toMap(keyMapper, valueMapper, mapFactory));
// final M res = mapFactory.get();
// res.putAll(collect(Collectors.toConcurrentMap(keyMapper, valueMapper, mergeFunction)));
// return res;
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public M call() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
M map = mapFactory.get();
try {
while (cursor < to && eHolder.value() == null) {
Collectors.merge(map, keyMapper.apply(elements[cursor]), valueMapper.apply(elements[cursor]), mergeFunction);
cursor++;
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public M call() {
M map = mapFactory.get();
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
Collectors.merge(map, keyMapper.apply(next), valueMapper.apply(next), mergeFunction);
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
}
if (eHolder.value() != null) {
close();
throw N.toRuntimeException(eHolder.value());
}
M res = null;
try {
for (ContinuableFuture future : futureList) {
if (res == null) {
res = future.get();
} else {
final M m = future.get();
for (Map.Entry entry : m.entrySet()) {
Collectors.merge(res, entry.getKey(), entry.getValue(), mergeFunction);
}
}
}
} catch (InterruptedException | ExecutionException e) {
throw N.toRuntimeException(e);
} finally {
close();
}
return res;
}
@Override
public > M toMap(final Function keyMapper, final Function valueMapper,
final Collector downstream, final Supplier mapFactory) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.toMap(keyMapper, valueMapper, downstream, mapFactory);
}
// return collect(Collectors.groupingBy(keyMapper, downstream, mapFactory));
// final M res = mapFactory.get();
// res.putAll(collect(Collectors.groupingByConcurrent(keyMapper, downstream)));
// return res;
final Supplier downstreamSupplier = downstream.supplier();
final BiConsumer downstreamAccumulator = downstream.accumulator();
final BinaryOperator downstreamCombiner = downstream.combiner();
final Function downstreamFinisher = downstream.finisher();
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List>> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
futureList.add(asyncExecutor.execute(new Callable>() {
@Override
public Map call() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
@SuppressWarnings("rawtypes")
Map map = (Map) mapFactory.get();
K key = null;
A value = null;
try {
while (cursor < to && eHolder.value() == null) {
key = checkArgNotNull(keyMapper.apply(elements[cursor]), "element cannot be mapped to a null key");
value = map.get(key);
if (value == null) {
value = downstreamSupplier.get();
map.put(key, value);
}
downstreamAccumulator.accept(value, valueMapper.apply(elements[cursor]));
cursor++;
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Callable>() {
@Override
public Map call() {
@SuppressWarnings("rawtypes")
Map map = (Map) mapFactory.get();
K key = null;
A value = null;
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
key = checkArgNotNull(keyMapper.apply(next), "element cannot be mapped to a null key");
value = map.get(key);
if (value == null) {
value = downstreamSupplier.get();
map.put(key, value);
}
downstreamAccumulator.accept(value, valueMapper.apply(next));
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
}
if (eHolder.value() != null) {
close();
throw N.toRuntimeException(eHolder.value());
}
Map intermediate = null;
try {
for (ContinuableFuture> future : futureList) {
if (intermediate == null) {
intermediate = future.get();
} else {
final Map m = future.get();
K key = null;
for (Map.Entry entry : m.entrySet()) {
key = entry.getKey();
if (intermediate.containsKey(key)) {
intermediate.put(key, downstreamCombiner.apply(intermediate.get(key), m.get(key)));
} else {
intermediate.put(key, m.get(key));
}
}
}
}
} catch (InterruptedException | ExecutionException e) {
throw N.toRuntimeException(e);
} finally {
close();
}
final BiFunction function = new BiFunction() {
@Override
public A apply(K k, A v) {
return (A) downstreamFinisher.apply(v);
}
};
Collectors.replaceAll(intermediate, function);
return (M) intermediate;
}
// @Override
// public > M flatToMap(final Function> flatKeyMapper,
// final BiFunction valueMapper, final BinaryOperator mergeFunction, final Supplier mapFactory) {
// assertNotClosed();
//
// if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
// return super.flatToMap(flatKeyMapper, valueMapper, mergeFunction, mapFactory);
// }
//
// // return collect(Collectors.toMap(keyMapper, valueMapper, mapFactory));
//
// // final M res = mapFactory.get();
// // res.putAll(collect(Collectors.toConcurrentMap(keyMapper, valueMapper, mergeFunction)));
// // return res;
//
// final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
// final List> futureList = new ArrayList<>(threadNum);
// final Holder eHolder = new Holder<>();
//
// if (splitor == Splitor.ARRAY) {
// final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
//
// for (int i = 0; i < threadNum; i++) {
// final int sliceIndex = i;
//
// futureList.add(asyncExecutor.execute(new Callable() {
// @Override
// public M call() {
// int cursor = fromIndex + sliceIndex * sliceSize;
// final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
//
// M map = mapFactory.get();
// ObjIterator keyIter = null;
// K key = null;
//
// try {
// while (cursor < to && eHolder.value() == null) {
// try (Stream ks = flatKeyMapper.apply(elements[cursor])) {
// keyIter = ks.iterator();
//
// while (keyIter.hasNext()) {
// key = keyIter.next();
// Collectors.merge(map, key, valueMapper.apply(key, elements[cursor]), mergeFunction);
// }
// }
//
// cursor++;
// }
// } catch (Exception e) {
// setError(eHolder, e);
// }
//
// return map;
// }
// }));
// }
// } else {
// final MutableInt cursor = MutableInt.of(fromIndex);
//
// for (int i = 0; i < threadNum; i++) {
// futureList.add(asyncExecutor.execute(new Callable() {
//
// @Override
// public M call() {
// M map = mapFactory.get();
// ObjIterator keyIter = null;
// T next = null;
// K key = null;
//
// try {
// while (eHolder.value() == null) {
// synchronized (elements) {
// if (cursor.intValue() < toIndex) {
// next = elements[cursor.getAndIncrement()];
// } else {
// break;
// }
// }
//
// try (Stream ks = flatKeyMapper.apply(next)) {
// keyIter = ks.iterator();
//
// while (keyIter.hasNext()) {
// key = keyIter.next();
// Collectors.merge(map, key, valueMapper.apply(key, next), mergeFunction);
// }
// }
// }
// } catch (Exception e) {
// setError(eHolder, e);
// }
//
// return map;
// }
// }));
// }
// }
//
// if (eHolder.value() != null) {
// close();
// throw N.toRuntimeException(eHolder.value());
// }
//
// M res = null;
//
// try {
// for (ContinuableFuture future : futureList) {
// if (res == null) {
// res = future.get();
// } else {
// final M m = future.get();
//
// for (Map.Entry entry : m.entrySet()) {
// Collectors.merge(res, entry.getKey(), entry.getValue(), mergeFunction);
// }
// }
// }
// } catch (InterruptedException | ExecutionException e) {
// throw N.toRuntimeException(e);
// } finally {
// close();
// }
//
// return res;
// }
//
// @Override
// public > M flatToMap(final Function> flatKeyMapper,
// final BiFunction valueMapper, final Collector downstream,
// final Supplier mapFactory) {
// assertNotClosed();
//
// if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
// return super.flatToMap(flatKeyMapper, valueMapper, downstream, mapFactory);
// }
//
// // return collect(Collectors.groupingBy(keyMapper, downstream, mapFactory));
//
// // final M res = mapFactory.get();
// // res.putAll(collect(Collectors.groupingByConcurrent(keyMapper, downstream)));
// // return res;
//
// final Supplier downstreamSupplier = downstream.supplier();
// final BiConsumer downstreamAccumulator = downstream.accumulator();
// final BinaryOperator downstreamCombiner = downstream.combiner();
// final Function downstreamFinisher = downstream.finisher();
//
// final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
// final List>> futureList = new ArrayList<>(threadNum);
// final Holder eHolder = new Holder<>();
//
// if (splitor == Splitor.ARRAY) {
// final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
//
// for (int i = 0; i < threadNum; i++) {
// final int sliceIndex = i;
//
// futureList.add(asyncExecutor.execute(new Callable>() {
// @Override
// public Map call() {
// int cursor = fromIndex + sliceIndex * sliceSize;
// final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
//
// @SuppressWarnings("rawtypes")
// Map map = (Map) mapFactory.get();
//
// ObjIterator keyIter = null;
// K key = null;
// A value = null;
//
// try {
// while (cursor < to && eHolder.value() == null) {
// try (Stream ks = flatKeyMapper.apply(elements[cursor])) {
// keyIter = ks.iterator();
//
// while (keyIter.hasNext()) {
// key = checkArgNotNull(keyIter.next(), "element cannot be mapped to a null key");
// value = map.get(key);
//
// if (value == null) {
// value = downstreamSupplier.get();
// map.put(key, value);
// }
//
// downstreamAccumulator.accept(value, valueMapper.apply(key, elements[cursor]));
// }
// }
//
// cursor++;
// }
// } catch (Exception e) {
// setError(eHolder, e);
// }
//
// return map;
// }
// }));
// }
// } else {
// final MutableInt cursor = MutableInt.of(fromIndex);
//
// for (int i = 0; i < threadNum; i++) {
// futureList.add(asyncExecutor.execute(new Callable>() {
//
// @Override
// public Map call() {
// @SuppressWarnings("rawtypes")
// Map map = (Map) mapFactory.get();
//
// ObjIterator keyIter = null;
// K key = null;
// A value = null;
// T next = null;
//
// try {
// while (eHolder.value() == null) {
// synchronized (elements) {
// if (cursor.intValue() < toIndex) {
// next = elements[cursor.getAndIncrement()];
// } else {
// break;
// }
// }
//
// try (Stream ks = flatKeyMapper.apply(next)) {
// keyIter = ks.iterator();
//
// while (keyIter.hasNext()) {
// key = checkArgNotNull(keyIter.next(), "element cannot be mapped to a null key");
// value = map.get(key);
//
// if (value == null) {
// value = downstreamSupplier.get();
// map.put(key, value);
// }
//
// downstreamAccumulator.accept(value, valueMapper.apply(key, next));
// }
// }
// }
// } catch (Exception e) {
// setError(eHolder, e);
// }
//
// return map;
// }
// }));
// }
// }
//
// if (eHolder.value() != null) {
// close();
// throw N.toRuntimeException(eHolder.value());
// }
//
// Map intermediate = null;
//
// try {
// for (ContinuableFuture> future : futureList) {
// if (intermediate == null) {
// intermediate = future.get();
// } else {
// final Map m = future.get();
// K key = null;
//
// for (Map.Entry entry : m.entrySet()) {
// key = entry.getKey();
//
// if (intermediate.containsKey(key)) {
// intermediate.put(key, downstreamCombiner.apply(intermediate.get(key), m.get(key)));
// } else {
// intermediate.put(key, m.get(key));
// }
// }
// }
// }
// } catch (InterruptedException | ExecutionException e) {
// throw N.toRuntimeException(e);
// } finally {
// close();
// }
//
// final BiFunction function = new BiFunction() {
// @Override
// public A apply(K k, A v) {
// return (A) downstreamFinisher.apply(v);
// }
// };
//
// Collectors.replaceAll(intermediate, function);
//
// return (M) intermediate;
// }
//
// @Override
// public > M flattToMap(final Function> flatKeyMapper,
// final BiFunction valueMapper, final BinaryOperator mergeFunction, final Supplier mapFactory) {
// return flatToMap(new Function>() {
// @Override
// public Stream apply(T t) {
// return Stream.of(flatKeyMapper.apply(t));
// }
// }, valueMapper, mergeFunction, mapFactory);
// }
//
// @Override
// public > M flattToMap(final Function> flatKeyMapper,
// final BiFunction valueMapper, final Collector downstream,
// final Supplier mapFactory) {
// return flatToMap(new Function>() {
// @Override
// public Stream apply(T t) {
// return Stream.of(flatKeyMapper.apply(t));
// }
// }, valueMapper, downstream, mapFactory);
// }
@Override
public , M extends Multimap> M toMultimap(final Function keyMapper,
final Function valueMapper, final Supplier mapFactory) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.toMultimap(keyMapper, valueMapper, mapFactory);
}
// return collect(Collectors.toMultimap(keyMapper, valueMapper, mapFactory));
// final M res = mapFactory.get();
// final ConcurrentMap> tmp = collect(Collectors.groupingByConcurrent(keyMapper, Collectors.mapping(valueMapper, Collectors. toList())));
//
// for (Map.Entry> entry : tmp.entrySet()) {
// res.putAll(entry.getKey(), entry.getValue());
// }
//
// return res;
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public M call() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
M map = mapFactory.get();
try {
while (cursor < to && eHolder.value() == null) {
map.put(keyMapper.apply(elements[cursor]), valueMapper.apply(elements[cursor]));
cursor++;
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public M call() {
M map = mapFactory.get();
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
map.put(keyMapper.apply(next), valueMapper.apply(next));
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
}
if (eHolder.value() != null) {
close();
throw N.toRuntimeException(eHolder.value());
}
M res = null;
try {
for (ContinuableFuture future : futureList) {
if (res == null) {
res = future.get();
} else {
final M m = future.get();
for (Map.Entry entry : m.entrySet()) {
res.putAll(entry.getKey(), entry.getValue());
}
}
}
} catch (InterruptedException | ExecutionException e) {
throw N.toRuntimeException(e);
} finally {
close();
}
return res;
}
@Override
public , M extends Multimap> M flatToMultimap(final Function> flatKeyMapper,
final BiFunction valueMapper, final Supplier mapFactory) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.flatToMultimap(flatKeyMapper, valueMapper, mapFactory);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public M call() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
M map = mapFactory.get();
ObjIterator keyIter = null;
K k = null;
try {
while (cursor < to && eHolder.value() == null) {
try (Stream ks = flatKeyMapper.apply(elements[cursor])) {
keyIter = ks.iterator();
while (keyIter.hasNext()) {
k = keyIter.next();
map.put(k, valueMapper.apply(k, elements[cursor]));
}
}
cursor++;
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public M call() {
M map = mapFactory.get();
ObjIterator keyIter = null;
K k = null;
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
try (Stream ks = flatKeyMapper.apply(next)) {
keyIter = ks.iterator();
while (keyIter.hasNext()) {
k = keyIter.next();
map.put(k, valueMapper.apply(k, next));
}
}
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
}
if (eHolder.value() != null) {
close();
throw N.toRuntimeException(eHolder.value());
}
M res = null;
try {
for (ContinuableFuture future : futureList) {
if (res == null) {
res = future.get();
} else {
final M m = future.get();
for (Map.Entry entry : m.entrySet()) {
res.putAll(entry.getKey(), entry.getValue());
}
}
}
} catch (InterruptedException | ExecutionException e) {
throw N.toRuntimeException(e);
} finally {
close();
}
return res;
}
@Override
public , M extends Multimap> M flattToMultimap(
final Function> flatKeyMapper, final BiFunction valueMapper,
final Supplier mapFactory) {
assertNotClosed();
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.flattToMultimap(flatKeyMapper, valueMapper, mapFactory);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
if (splitor == Splitor.ARRAY) {
final int sliceSize = (toIndex - fromIndex) / threadNum + ((toIndex - fromIndex) % threadNum == 0 ? 0 : 1);
for (int i = 0; i < threadNum; i++) {
final int sliceIndex = i;
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public M call() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
M map = mapFactory.get();
Collection ks = null;
try {
while (cursor < to && eHolder.value() == null) {
ks = flatKeyMapper.apply(elements[cursor]);
if (N.notNullOrEmpty(ks)) {
for (K k : ks) {
map.put(k, valueMapper.apply(k, elements[cursor]));
}
}
cursor++;
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public M call() {
M map = mapFactory.get();
Collection ks = null;
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
ks = flatKeyMapper.apply(next);
if (N.notNullOrEmpty(ks)) {
for (K k : ks) {
map.put(k, valueMapper.apply(k, next));
}
}
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
}
if (eHolder.value() != null) {
close();
throw N.toRuntimeException(eHolder.value());
}
M res = null;
try {
for (ContinuableFuture future : futureList) {
if (res == null) {
res = future.get();
} else {
final M m = future.get();
for (Map.Entry entry : m.entrySet()) {
res.putAll(entry.getKey(), entry.getValue());
}
}
}
} catch (InterruptedException | ExecutionException e) {
throw N.toRuntimeException(e);
} finally {
close();
}
return res;
}
@Override
public Map