com.landawn.abacus.util.stream.ParallelArrayStream Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of abacus-android Show documentation
Show all versions of abacus-android Show documentation
A general programming library in Java
/*
* Copyright (C) 2016 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.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
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;
import com.landawn.abacus.util.Holder;
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.Optional;
import com.landawn.abacus.util.Pair;
import com.landawn.abacus.util.ShortIterator;
import com.landawn.abacus.util.Try;
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;
/**
* This class is a sequential, stateful and immutable stream implementation.
*
* @param
* @since 0.8
*
* @author Haiyang Li
*/
final class ParallelArrayStream extends ArrayStream {
private final int maxThreadNum;
private final Splitor splitor;
private volatile ArrayStream sequential;
ParallelArrayStream(final T[] values, final int fromIndex, final int toIndex, final boolean sorted, Comparator comparator, int maxThreadNum,
Splitor splitor, final Collection closeHandlers) {
super(values, fromIndex, toIndex, sorted, comparator, closeHandlers);
this.maxThreadNum = checkMaxThreadNum(maxThreadNum);
this.splitor = splitor == null ? DEFAULT_SPLITOR : splitor;
}
@Override
public Stream filter(final Predicate predicate) {
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, closeHandlers);
}
@Override
public Stream takeWhile(final Predicate predicate) {
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, closeHandlers);
}
@Override
public Stream dropWhile(final Predicate predicate) {
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, closeHandlers);
}
@Override
public Stream map(final Function mapper) {
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, closeHandlers);
}
// @Override
// public Stream biMap(final BiFunction mapper, final boolean ignoreNotPaired) {
// if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
// return new ParallelIteratorStream<>(sequential().biMap(mapper, ignoreNotPaired).iterator(), false, null, maxThreadNum, splitor, closeHandlers);
// }
//
// final int atLeast = ignoreNotPaired ? 2 : 1;
// final int count = (toIndex - fromIndex) / 2 + (ignoreNotPaired || (toIndex - fromIndex) % 2 == 0 ? 0 : 1);
// final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
// final List> iters = new ArrayList<>(threadNum);
//
// if (splitor == Splitor.ARRAY) {
// final int sliceSize = count / maxThreadNum + (count % maxThreadNum == 0 ? 0 : 1);
//
// for (int i = 0; i < threadNum; i++) {
// final int sliceIndex = i;
// iters.add(new ObjIteratorEx() {
// private int cursor = fromIndex + sliceIndex * sliceSize * 2;
// private final int to = toIndex - cursor > sliceSize * 2 ? cursor + sliceSize * 2 : toIndex;
//
// @Override
// public boolean hasNext() {
// return to - cursor >= atLeast;
// }
//
// @Override
// public R next() {
// if (to - cursor < atLeast) {
// throw new NoSuchElementException();
// }
//
// return mapper.apply(elements[cursor++], cursor == toIndex ? null : elements[cursor++]);
// }
// });
// }
// } else {
// final MutableInt cursor = MutableInt.of(fromIndex);
//
// for (int i = 0; i < threadNum; i++) {
// iters.add(new ObjIteratorEx() {
//
// private Object pre = NONE;
// private Object next = NONE;
//
// @Override
// public boolean hasNext() {
// if (pre == NONE) {
// synchronized (elements) {
// if (toIndex - cursor.intValue() >= atLeast) {
// pre = elements[cursor.getAndIncrement()];
// next = cursor.intValue() == toIndex ? null : elements[cursor.getAndIncrement()];
// }
// }
// }
//
// return pre != NONE;
// }
//
// @Override
// public R next() {
// if (pre == NONE && hasNext() == false) {
// throw new NoSuchElementException();
// }
//
// final R result = mapper.apply((T) pre, (T) next);
// pre = NONE;
// next = NONE;
// return result;
// }
//
// });
// }
// }
//
// return new ParallelIteratorStream<>(Stream.parallelConcatt(iters, iters.size()), false, null, maxThreadNum, splitor, closeHandlers);
// }
//
// @Override
// public Stream triMap(final TriFunction mapper, final boolean ignoreNotPaired) {
// if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
// return new ParallelIteratorStream<>(sequential().triMap(mapper, ignoreNotPaired).iterator(), false, null, maxThreadNum, splitor, closeHandlers);
// }
//
// final int atLeast = ignoreNotPaired ? 3 : 1;
// final int count = (toIndex - fromIndex) / 3 + (ignoreNotPaired || (toIndex - fromIndex) % 3 == 0 ? 0 : 1);
// final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
// final List> iters = new ArrayList<>(threadNum);
//
// if (splitor == Splitor.ARRAY) {
// final int sliceSize = count / maxThreadNum + (count % maxThreadNum == 0 ? 0 : 1);
//
// for (int i = 0; i < threadNum; i++) {
// final int sliceIndex = i;
// iters.add(new ObjIteratorEx() {
// private int cursor = fromIndex + sliceIndex * sliceSize * 3;
// private final int to = toIndex - cursor > sliceSize * 3 ? cursor + sliceSize * 3 : toIndex;
//
// @Override
// public boolean hasNext() {
// return to - cursor >= atLeast;
// }
//
// @Override
// public R next() {
// if (to - cursor < atLeast) {
// throw new NoSuchElementException();
// }
//
// return mapper.apply(elements[cursor++], cursor == toIndex ? null : elements[cursor++], cursor == toIndex ? null : elements[cursor++]);
// }
// });
// }
// } else {
// final MutableInt cursor = MutableInt.of(fromIndex);
//
// for (int i = 0; i < threadNum; i++) {
// iters.add(new ObjIteratorEx() {
//
// private Object prepre = NONE;
// private Object pre = NONE;
// private Object next = NONE;
//
// @Override
// public boolean hasNext() {
// if (prepre == NONE) {
// synchronized (elements) {
// if (toIndex - cursor.intValue() >= atLeast) {
// prepre = elements[cursor.getAndIncrement()];
// pre = cursor.intValue() == toIndex ? null : elements[cursor.getAndIncrement()];
// next = cursor.intValue() == toIndex ? null : elements[cursor.getAndIncrement()];
// }
// }
// }
//
// return prepre != NONE;
// }
//
// @Override
// public R next() {
// if (prepre == NONE && hasNext() == false) {
// throw new NoSuchElementException();
// }
//
// final R result = mapper.apply((T) prepre, (T) pre, (T) next);
// prepre = NONE;
// pre = NONE;
// next = NONE;
// return result;
// }
//
// });
// }
// }
//
// return new ParallelIteratorStream<>(Stream.parallelConcatt(iters, iters.size()), false, null, maxThreadNum, splitor, closeHandlers);
// }
@Override
public Stream slidingMap(final BiFunction mapper, final int increment, final boolean ignoreNotPaired) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorStream<>(sequential().slidingMap(mapper, increment).iterator(), false, null, maxThreadNum, splitor, closeHandlers);
}
final int windowSize = 2;
N.checkArgument(increment > 0, "'increment'=%s must not be less than 1", 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, closeHandlers);
}
@Override
public Stream slidingMap(final TriFunction mapper, final int increment, final boolean ignoreNotPaired) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorStream<>(sequential().slidingMap(mapper, increment).iterator(), false, null, maxThreadNum, splitor, closeHandlers);
}
final int windowSize = 3;
N.checkArgument(increment > 0, "'increment'=%s must not be less than 1", 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, closeHandlers);
}
@Override
public Stream mapFirstOrElse(final Function mapperForFirst, final Function mapperForElse) {
N.checkArgNotNull(mapperForFirst);
N.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) {
N.checkArgNotNull(mapperForLast);
N.checkArgNotNull(mapperForElse);
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorStream<>(sequential().mapLastOrElse(mapperForLast, mapperForElse).iterator(), false, null, maxThreadNum, splitor,
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) {
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, closeHandlers);
}
@Override
public ByteStream mapToByte(final ToByteFunction mapper) {
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, closeHandlers);
}
@Override
public ShortStream mapToShort(final ToShortFunction mapper) {
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, closeHandlers);
}
@Override
public IntStream mapToInt(final ToIntFunction mapper) {
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, closeHandlers);
}
@Override
public LongStream mapToLong(final ToLongFunction mapper) {
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, closeHandlers);
}
@Override
public FloatStream mapToFloat(final ToFloatFunction mapper) {
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, closeHandlers);
}
@Override
public DoubleStream mapToDouble(final ToDoubleFunction mapper) {
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, closeHandlers);
}
@Override
public Stream flatMap(final Function> mapper) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorStream<>(sequential().flatMap(mapper), false, null, maxThreadNum, splitor, 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 Set 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 Set 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 Set newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalLinkedHashSet(1)
: new LocalLinkedHashSet(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorStream<>(Stream.parallelConcatt(iters, iters.size()), false, null, maxThreadNum, splitor, newCloseHandlers);
}
@Override
public CharStream flatMapToChar(final Function mapper) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorCharStream(sequential().flatMapToChar(mapper), false, maxThreadNum, splitor, 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 Set 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 Set 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 Set newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalLinkedHashSet(1)
: new LocalLinkedHashSet(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorCharStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, newCloseHandlers);
}
@Override
public ByteStream flatMapToByte(final Function mapper) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorByteStream(sequential().flatMapToByte(mapper), false, maxThreadNum, splitor, 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 Set 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 Set 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 Set newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalLinkedHashSet(1)
: new LocalLinkedHashSet(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorByteStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, newCloseHandlers);
}
@Override
public ShortStream flatMapToShort(final Function mapper) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorShortStream(sequential().flatMapToShort(mapper), false, maxThreadNum, splitor, 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 Set 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 Set 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 Set newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalLinkedHashSet(1)
: new LocalLinkedHashSet(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorShortStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, newCloseHandlers);
}
@Override
public IntStream flatMapToInt(final Function mapper) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorIntStream(sequential().flatMapToInt(mapper), false, maxThreadNum, splitor, 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 Set 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 Set 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 Set newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalLinkedHashSet(1)
: new LocalLinkedHashSet(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorIntStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, newCloseHandlers);
}
@Override
public LongStream flatMapToLong(final Function mapper) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorLongStream(sequential().flatMapToLong(mapper), false, maxThreadNum, splitor, 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 Set 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 Set 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 Set newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalLinkedHashSet(1)
: new LocalLinkedHashSet(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorLongStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, newCloseHandlers);
}
@Override
public FloatStream flatMapToFloat(final Function mapper) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorFloatStream(sequential().flatMapToFloat(mapper), false, maxThreadNum, splitor, 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 Set 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 Set 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 Set newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalLinkedHashSet(1)
: new LocalLinkedHashSet(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorFloatStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, newCloseHandlers);
}
@Override
public DoubleStream flatMapToDouble(final Function mapper) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return new ParallelIteratorDoubleStream(sequential().flatMapToDouble(mapper), false, maxThreadNum, splitor, 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 Set 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 Set 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 Set newCloseHandlers = N.isNullOrEmpty(closeHandlers) ? new LocalLinkedHashSet(1)
: new LocalLinkedHashSet(closeHandlers);
newCloseHandlers.add(new Runnable() {
@Override
public void run() {
Stream.close(iters);
}
});
return new ParallelIteratorDoubleStream(Stream.parallelConcatt(iters, iters.size()), false, maxThreadNum, splitor, newCloseHandlers);
}
@Override
public Stream peek(final Consumer action) {
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, closeHandlers);
}
@Override
public void forEach(final Try.Consumer action) throws E {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
super.forEach(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 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 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);
}
}
}));
}
}
complette(futureList, eHolder, (E) null);
}
@Override
public void forEachPair(final Try.BiConsumer action, final int increment) throws E {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
super.forEachPair(action, increment);
return;
}
final int windowSize = 2;
N.checkArgument(increment > 0, "'increment'=%s must not be less than 1", 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 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);
}
}
}));
}
complette(futureList, eHolder, (E) null);
}
@Override
public void forEachTriple(final Try.TriConsumer action, final int increment) throws E {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
super.forEachTriple(action, increment);
return;
}
final int windowSize = 3;
N.checkArgument(increment > 0, "'increment'=%s must not be less than 1", 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 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);
}
}
}));
}
complette(futureList, eHolder, (E) null);
}
@Override
A[] toArray(A[] a) {
if (a.length < (toIndex - fromIndex)) {
a = N.newArray(a.getClass().getComponentType(), toIndex - fromIndex);
}
N.copy(elements, fromIndex, a, 0, toIndex - fromIndex);
return a;
}
@Override
public > M toMap(final Function keyExtractor, final Function valueMapper,
final BinaryOperator mergeFunction, final Supplier mapFactory) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.toMap(keyExtractor, valueMapper, mapFactory);
}
// return collect(Collectors.toMap(keyExtractor, valueMapper, mapFactory));
// final M res = mapFactory.get();
// res.putAll(collect(Collectors.toConcurrentMap(keyExtractor, 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, keyExtractor.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, keyExtractor.apply(next), valueMapper.apply(next), mergeFunction);
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
}
if (eHolder.value() != null) {
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);
}
return res;
}
@Override
public > M toMap(final Function classifier, final Collector downstream,
final Supplier mapFactory) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.toMap(classifier, downstream, mapFactory);
}
// return collect(Collectors.groupingBy(classifier, downstream, mapFactory));
// final M res = mapFactory.get();
// res.putAll(collect(Collectors.groupingByConcurrent(classifier, 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 = N.checkArgNotNull(classifier.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, 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 = N.checkArgNotNull(classifier.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, next);
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
}
if (eHolder.value() != null) {
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);
}
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 extends Multimap> M toMultimap(final Function keyExtractor,
final Function valueMapper, final Supplier mapFactory) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.toMultimap(keyExtractor, valueMapper, mapFactory);
}
// return collect(Collectors.toMultimap(keyExtractor, valueMapper, mapFactory));
// final M res = mapFactory.get();
// final ConcurrentMap> tmp = collect(Collectors.groupingByConcurrent(keyExtractor, 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(keyExtractor.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(keyExtractor.apply(next), valueMapper.apply(next));
}
} catch (Exception e) {
setError(eHolder, e);
}
return map;
}
}));
}
}
if (eHolder.value() != null) {
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);
}
return res;
}
@Override
public Map partitionTo(final Predicate predicate, Collector downstream) {
final Function keyExtractor = new Function() {
@Override
public Boolean apply(T t) {
return predicate.test(t);
}
};
final Supplier> mapFactory = Fn.Suppliers.ofMap();
final Map map = toMap(keyExtractor, downstream, mapFactory);
if (map.containsKey(Boolean.TRUE) == false) {
map.put(Boolean.TRUE, downstream.finisher().apply(downstream.supplier().get()));
} else if (map.containsKey(Boolean.FALSE) == false) {
map.put(Boolean.FALSE, downstream.finisher().apply(downstream.supplier().get()));
}
return map;
}
@Override
public T reduce(final T identity, final BinaryOperator accumulator) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.reduce(identity, accumulator);
}
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 T call() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
T result = identity;
try {
while (cursor < to && eHolder.value() == null) {
result = accumulator.apply(result, elements[cursor++]);
}
} catch (Exception e) {
setError(eHolder, e);
}
return result;
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public T call() {
T result = identity;
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
result = accumulator.apply(result, next);
}
} catch (Exception e) {
setError(eHolder, e);
}
return result;
}
}));
}
}
if (eHolder.value() != null) {
throw N.toRuntimeException(eHolder.value());
}
T result = (T) NONE;
try {
for (ContinuableFuture future : futureList) {
if (result == NONE) {
result = future.get();
} else {
result = accumulator.apply(result, future.get());
}
}
} catch (InterruptedException | ExecutionException e) {
throw N.toRuntimeException(e);
}
return result == NONE ? identity : result;
}
@Override
public Optional reduce(final BinaryOperator accumulator) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.reduce(accumulator);
}
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 T call() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
if (cursor >= to) {
return (T) NONE;
}
T result = elements[cursor++];
try {
while (cursor < to && eHolder.value() == null) {
result = accumulator.apply(result, elements[cursor++]);
}
} catch (Exception e) {
setError(eHolder, e);
}
return result;
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public T call() {
T result = null;
synchronized (elements) {
if (cursor.intValue() < toIndex) {
result = elements[cursor.getAndIncrement()];
} else {
return (T) NONE;
}
}
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
result = accumulator.apply(result, next);
}
} catch (Exception e) {
setError(eHolder, e);
}
return result;
}
}));
}
}
if (eHolder.value() != null) {
throw N.toRuntimeException(eHolder.value());
}
T result = (T) NONE;
try {
for (ContinuableFuture future : futureList) {
final T tmp = future.get();
if (tmp == NONE) {
continue;
} else if (result == NONE) {
result = tmp;
} else {
result = accumulator.apply(result, tmp);
}
}
} catch (InterruptedException | ExecutionException e) {
throw N.toRuntimeException(e);
}
return result == NONE ? (Optional) Optional.empty() : Optional.of(result);
}
@Override
public U reduce(final U identity, final BiFunction accumulator, final BinaryOperator combiner) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.reduce(identity, accumulator, combiner);
}
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 U call() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
U result = identity;
try {
while (cursor < to && eHolder.value() == null) {
result = accumulator.apply(result, elements[cursor++]);
}
} catch (Exception e) {
setError(eHolder, e);
}
return result;
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public U call() {
U result = identity;
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
result = accumulator.apply(result, next);
}
} catch (Exception e) {
setError(eHolder, e);
}
return result;
}
}));
}
}
if (eHolder.value() != null) {
throw N.toRuntimeException(eHolder.value());
}
U result = (U) NONE;
try {
for (ContinuableFuture future : futureList) {
final U tmp = future.get();
if (result == NONE) {
result = tmp;
} else {
result = combiner.apply(result, tmp);
}
}
} catch (InterruptedException | ExecutionException e) {
throw N.toRuntimeException(e);
}
return result == NONE ? identity : result;
}
@Override
public R collect(final Supplier supplier, final BiConsumer accumulator, final BiConsumer combiner) {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.collect(supplier, accumulator, combiner);
}
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 R call() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
final R container = supplier.get();
try {
while (cursor < to && eHolder.value() == null) {
accumulator.accept(container, elements[cursor++]);
}
} catch (Exception e) {
setError(eHolder, e);
}
return container;
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public R call() {
final R container = supplier.get();
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
accumulator.accept(container, next);
}
} catch (Exception e) {
setError(eHolder, e);
}
return container;
}
}));
}
}
if (eHolder.value() != null) {
throw N.toRuntimeException(eHolder.value());
}
R container = (R) NONE;
try {
for (ContinuableFuture future : futureList) {
if (container == NONE) {
container = future.get();
} else {
combiner.accept(container, future.get());
}
}
} catch (InterruptedException | ExecutionException e) {
throw N.toRuntimeException(e);
}
return container == NONE ? supplier.get() : container;
}
@Override
public R collect(Collector collector) {
if (maxThreadNum <= 1 || collector.characteristics().contains(Collector.Characteristics.CONCURRENT) == false
|| collector.characteristics().contains(Collector.Characteristics.UNORDERED) == false) {
return sequential().collect(collector);
}
final Supplier supplier = collector.supplier();
final BiConsumer accumulator = collector.accumulator();
final BinaryOperator combiner = collector.combiner();
final Function finisher = collector.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 A call() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
A container = supplier.get();
try {
while (cursor < to && eHolder.value() == null) {
accumulator.accept(container, elements[cursor++]);
}
} catch (Exception e) {
setError(eHolder, e);
}
return container;
}
}));
}
} else {
final MutableInt cursor = MutableInt.of(fromIndex);
for (int i = 0; i < threadNum; i++) {
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public A call() {
A container = supplier.get();
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
accumulator.accept(container, next);
}
} catch (Exception e) {
setError(eHolder, e);
}
return container;
}
}));
}
}
if (eHolder.value() != null) {
throw N.toRuntimeException(eHolder.value());
}
A container = (A) NONE;
try {
for (ContinuableFuture future : futureList) {
if (container == NONE) {
container = future.get();
} else {
container = combiner.apply(container, future.get());
}
}
} catch (InterruptedException | ExecutionException e) {
throw N.toRuntimeException(e);
}
return finisher.apply(container == NONE ? supplier.get() : container);
}
@Override
public Optional min(Comparator comparator) {
if (fromIndex == toIndex) {
return Optional.empty();
} else if (sorted && isSameComparator(cmp, comparator)) {
return Optional.of(elements[fromIndex]);
}
comparator = comparator == null ? NATURAL_COMPARATOR : comparator;
return collect(Collectors.minBy(comparator));
}
@Override
public Optional max(Comparator comparator) {
if (fromIndex == toIndex) {
return Optional.empty();
} else if (sorted && isSameComparator(cmp, comparator)) {
return Optional.of(elements[toIndex - 1]);
}
comparator = comparator == null ? NATURAL_COMPARATOR : comparator;
return collect(Collectors.maxBy(comparator));
}
@Override
public boolean anyMatch(final Try.Predicate predicate) throws E {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.anyMatch(predicate);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
final MutableBoolean result = MutableBoolean.of(false);
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 Runnable() {
@Override
public void run() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
try {
while (cursor < to && result.isFalse() && eHolder.value() == null) {
if (predicate.test(elements[cursor++])) {
result.setTrue();
break;
}
}
} 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 Runnable() {
@Override
public void run() {
T next = null;
try {
while (result.isFalse() && eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
if (predicate.test(next)) {
result.setTrue();
break;
}
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
}
complette(futureList, eHolder, (E) null);
return result.value();
}
@Override
public boolean allMatch(final Try.Predicate predicate) throws E {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.allMatch(predicate);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
final MutableBoolean result = MutableBoolean.of(true);
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 Runnable() {
@Override
public void run() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
try {
while (cursor < to && result.isTrue() && eHolder.value() == null) {
if (predicate.test(elements[cursor++]) == false) {
result.setFalse();
break;
}
}
} 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 Runnable() {
@Override
public void run() {
T next = null;
try {
while (result.isTrue() && eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
if (predicate.test(next) == false) {
result.setFalse();
break;
}
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
}
complette(futureList, eHolder, (E) null);
return result.value();
}
@Override
public boolean noneMatch(final Try.Predicate predicate) throws E {
if (maxThreadNum <= 1 || toIndex - fromIndex <= 1) {
return super.noneMatch(predicate);
}
final int threadNum = N.min(maxThreadNum, (toIndex - fromIndex));
final List> futureList = new ArrayList<>(threadNum);
final Holder eHolder = new Holder<>();
final MutableBoolean result = MutableBoolean.of(true);
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 Runnable() {
@Override
public void run() {
int cursor = fromIndex + sliceIndex * sliceSize;
final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
try {
while (cursor < to && result.isTrue() && eHolder.value() == null) {
if (predicate.test(elements[cursor++])) {
result.setFalse();
break;
}
}
} 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 Runnable() {
@Override
public void run() {
T next = null;
try {
while (result.isTrue() && eHolder.value() == null) {
synchronized (elements) {
if (cursor.intValue() < toIndex) {
next = elements[cursor.getAndIncrement()];
} else {
break;
}
}
if (predicate.test(next)) {
result.setFalse();
break;
}
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
}
complette(futureList, eHolder, (E) null);
return result.value();
}
@Override
public