com.landawn.abacus.util.stream.ParallelIteratorStream 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.MutableLong;
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 ParallelIteratorStream extends IteratorStream {
private final int maxThreadNum;
private final Splitor splitor;
private volatile IteratorStream sequential;
ParallelIteratorStream(final Iterator values, final boolean sorted, final Comparator comparator, final int maxThreadNum,
final Splitor splitor, final Collection closeHandlers) {
super(values, sorted, comparator, closeHandlers);
this.maxThreadNum = checkMaxThreadNum(maxThreadNum);
this.splitor = splitor == null ? DEFAULT_SPLITOR : splitor;
}
ParallelIteratorStream(final Stream stream, final boolean sorted, final Comparator comparator, final int maxThreadNum, final Splitor splitor,
final Set closeHandlers) {
this(stream.iterator(), sorted, comparator, maxThreadNum, splitor, mergeCloseHandlers(stream, closeHandlers));
}
@Override
public Stream filter(final Predicate predicate) {
if (maxThreadNum <= 1) {
return super.filter(predicate);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
return super.takeWhile(predicate);
}
final List> iters = new ArrayList<>(maxThreadNum);
final MutableBoolean hasMore = MutableBoolean.of(true);
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
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) {
return super.dropWhile(predicate);
}
final List> iters = new ArrayList<>(maxThreadNum);
final MutableBoolean dropped = MutableBoolean.of(false);
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
hasNext = true;
}
}
} else {
while (dropped.isFalse()) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
} else {
break;
}
}
if (predicate.test(next) == false) {
hasNext = true;
dropped.setTrue();
break;
}
}
if (hasNext == false && dropped.isTrue()) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
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) {
return super.map(mapper);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
}
}
}
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) {
// return new ParallelIteratorStream<>(sequential().biMap(mapper, ignoreNotPaired).iterator(), false, null, maxThreadNum, splitor, closeHandlers);
// }
//
// final List> iters = new ArrayList<>(maxThreadNum);
//
// for (int i = 0; i < maxThreadNum; i++) {
// iters.add(new ObjIteratorEx() {
// private Object pre = NONE;
// private Object next = NONE;
//
// @Override
// public boolean hasNext() {
// if (pre == NONE) {
// synchronized (elements) {
// if (elements.hasNext()) {
// pre = elements.next();
//
// if (elements.hasNext()) {
// next = elements.next();
// }
// }
// }
// }
//
// return ignoreNotPaired ? next != NONE : pre != NONE;
// }
//
// @Override
// public R next() {
// if (next == NONE && hasNext() == false) {
// throw new NoSuchElementException();
// }
//
// final R result = mapper.apply((T) pre, next == NONE ? null : (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) {
// return new ParallelIteratorStream<>(sequential().triMap(mapper, ignoreNotPaired).iterator(), false, null, maxThreadNum, splitor, closeHandlers);
// }
//
// final List> iters = new ArrayList<>(maxThreadNum);
//
// for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
// prepre = elements.next();
//
// if (elements.hasNext()) {
// pre = elements.next();
//
// if (elements.hasNext()) {
// next = elements.next();
// }
// }
// }
// }
// }
//
// return ignoreNotPaired ? next != NONE : prepre != NONE;
// }
//
// @Override
// public R next() {
// if (next == NONE && hasNext() == false) {
// throw new NoSuchElementException();
// }
//
// final R result = mapper.apply((T) prepre, pre == NONE ? null : (T) pre, next == NONE ? null : (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) {
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 MutableBoolean isFirst = MutableBoolean.of(true);
final Holder prev = new Holder<>();
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
@SuppressWarnings("unchecked")
private final T NONE = (T) Stream.NONE;
private T first = NONE;
private T second = NONE;
@Override
public boolean hasNext() {
if (first == NONE) {
synchronized (elements) {
if (elements.hasNext()) {
if (increment > windowSize && isFirst.isFalse()) {
int skipNum = increment - windowSize;
while (skipNum-- > 0 && elements.hasNext()) {
elements.next();
}
}
if (elements.hasNext()) {
if (increment == 1) {
first = isFirst.isTrue() ? elements.next() : prev.value();
second = elements.hasNext() ? elements.next() : null;
prev.setValue(second);
} else {
first = elements.next();
second = elements.hasNext() ? elements.next() : null;
}
}
isFirst.setFalse();
}
}
}
return ignoreNotPaired ? second != NONE : first != NONE;
}
@Override
public R next() {
if ((ignoreNotPaired ? second == NONE : first == NONE) && hasNext() == false) {
throw new NoSuchElementException();
}
final R result = mapper.apply(first, second == NONE ? null : second);
first = NONE;
second = NONE;
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) {
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 MutableBoolean isFirst = MutableBoolean.of(true);
final Holder prev = new Holder<>();
final Holder prev2 = new Holder<>();
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
@SuppressWarnings("unchecked")
private final T NONE = (T) Stream.NONE;
private T first = NONE;
private T second = NONE;
private T third = NONE;
@Override
public boolean hasNext() {
if (first == NONE) {
synchronized (elements) {
if (elements.hasNext()) {
if (increment > windowSize && isFirst.isFalse()) {
int skipNum = increment - windowSize;
while (skipNum-- > 0 && elements.hasNext()) {
elements.next();
}
}
if (elements.hasNext()) {
if (increment == 1) {
first = isFirst.isTrue() ? elements.next() : prev2.value();
second = isFirst.isTrue() ? (elements.hasNext() ? elements.next() : null) : prev.value();
third = elements.hasNext() ? elements.next() : null;
prev2.setValue(second);
prev.setValue(third);
} else if (increment == 2) {
first = isFirst.isTrue() ? elements.next() : prev.value();
second = elements.hasNext() ? elements.next() : null;
third = elements.hasNext() ? elements.next() : null;
prev.setValue(third);
} else {
first = elements.next();
second = elements.hasNext() ? elements.next() : null;
third = elements.hasNext() ? elements.next() : null;
}
}
isFirst.setFalse();
}
}
}
return ignoreNotPaired ? third != NONE : first != NONE;
}
@Override
public R next() {
if ((ignoreNotPaired ? third == NONE : first == NONE) && hasNext() == false) {
throw new NoSuchElementException();
}
final R result = mapper.apply(first, second == NONE ? null : second, third == NONE ? null : third);
first = NONE;
second = NONE;
third = NONE;
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) {
return super.mapFirstOrElse(mapperForFirst, mapperForElse);
}
if (elements.hasNext()) {
final Function mapperForFirst2 = (Function) mapperForFirst;
final Function mapperForElse2 = (Function) mapperForElse;
final T first = elements.next();
return map(mapperForElse2).prepend(Stream.of(first).map(mapperForFirst2));
} else {
return (Stream) this;
}
}
@Override
public Stream mapLastOrElse(final Function mapperForLast, final Function mapperForElse) {
N.checkArgNotNull(mapperForLast);
N.checkArgNotNull(mapperForElse);
if (maxThreadNum <= 1) {
return super.mapLastOrElse(mapperForLast, mapperForElse);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
private boolean isLast = false;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
if (elements.hasNext() == false) {
isLast = true;
}
}
}
}
return next != NONE;
}
@Override
public R next() {
if (next == NONE && hasNext() == false) {
throw new NoSuchElementException();
}
final R result = isLast ? mapperForLast.apply((T) next) : mapperForElse.apply((T) next);
next = NONE;
return result;
}
});
}
return new ParallelIteratorStream<>(Stream.parallelConcatt(iters, iters.size()), false, null, maxThreadNum, splitor, closeHandlers);
}
@Override
public CharStream mapToChar(final ToCharFunction mapper) {
if (maxThreadNum <= 1) {
return super.mapToChar(mapper);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
}
}
}
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) {
return super.mapToByte(mapper);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
}
}
}
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) {
return super.mapToShort(mapper);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
}
}
}
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) {
return super.mapToInt(mapper);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
}
}
}
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) {
return super.mapToLong(mapper);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
}
}
}
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) {
return super.mapToFloat(mapper);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
}
}
}
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) {
return super.mapToDouble(mapper);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
}
}
}
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) {
return new ParallelIteratorStream<>(sequential().flatMap(mapper), false, null, maxThreadNum, splitor, null);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
return new ParallelIteratorCharStream(sequential().flatMapToChar(mapper), false, maxThreadNum, splitor, null);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
return new ParallelIteratorByteStream(sequential().flatMapToByte(mapper), false, maxThreadNum, splitor, null);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
return new ParallelIteratorShortStream(sequential().flatMapToShort(mapper), false, maxThreadNum, splitor, null);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
return new ParallelIteratorIntStream(sequential().flatMapToInt(mapper), false, maxThreadNum, splitor, null);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
return new ParallelIteratorLongStream(sequential().flatMapToLong(mapper), false, maxThreadNum, splitor, null);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
return new ParallelIteratorFloatStream(sequential().flatMapToFloat(mapper), false, maxThreadNum, splitor, null);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
return new ParallelIteratorDoubleStream(sequential().flatMapToDouble(mapper), false, maxThreadNum, splitor, null);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
return super.peek(action);
}
final List> iters = new ArrayList<>(maxThreadNum);
for (int i = 0; i < maxThreadNum; i++) {
iters.add(new ObjIteratorEx() {
private Object next = NONE;
@Override
public boolean hasNext() {
if (next == NONE) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
}
}
}
return next != NONE;
}
@Override
public T next() {
if (next == NONE && hasNext() == false) {
throw new NoSuchElementException();
}
final 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) {
super.forEach(action);
return;
}
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
for (int i = 0; i < maxThreadNum; i++) {
futureList.add(asyncExecutor.execute(new Runnable() {
@Override
public void run() {
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
} 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) {
super.forEachPair(action, increment);
return;
}
final int windowSize = 2;
N.checkArgument(increment > 0, "'increment'=%s must not be less than 1", increment);
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
final Holder prev = new Holder<>();
final MutableBoolean isFirst = MutableBoolean.of(true);
for (int i = 0; i < maxThreadNum; i++) {
futureList.add(asyncExecutor.execute(new Runnable() {
private T first = null;
private T second = null;
@Override
public void run() {
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (elements.hasNext()) {
if (increment > windowSize && isFirst.isFalse()) {
int skipNum = increment - windowSize;
while (skipNum-- > 0 && elements.hasNext()) {
elements.next();
}
if (elements.hasNext() == false) {
break;
}
}
if (increment == 1) {
first = isFirst.isTrue() ? elements.next() : prev.value();
second = elements.hasNext() ? elements.next() : null;
prev.setValue(second);
} else {
first = elements.next();
second = elements.hasNext() ? elements.next() : null;
}
isFirst.setFalse();
} else {
break;
}
}
action.accept(first, second);
}
} 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) {
super.forEachTriple(action, increment);
return;
}
final int windowSize = 3;
N.checkArgument(increment > 0, "'increment'=%s must not be less than 1", increment);
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
final Holder prev = new Holder<>();
final Holder prev2 = new Holder<>();
final MutableBoolean isFirst = MutableBoolean.of(true);
for (int i = 0; i < maxThreadNum; i++) {
futureList.add(asyncExecutor.execute(new Runnable() {
private T first = null;
private T second = null;
private T third = null;
@Override
public void run() {
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (elements.hasNext()) {
if (increment > windowSize && isFirst.isFalse()) {
int skipNum = increment - windowSize;
while (skipNum-- > 0 && elements.hasNext()) {
elements.next();
}
if (elements.hasNext() == false) {
break;
}
}
if (increment == 1) {
first = isFirst.isTrue() ? elements.next() : prev2.value();
second = isFirst.isTrue() ? (elements.hasNext() ? elements.next() : null) : prev.value();
third = elements.hasNext() ? elements.next() : null;
prev2.setValue(second);
prev.setValue(third);
} else if (increment == 2) {
first = isFirst.isTrue() ? elements.next() : prev.value();
second = elements.hasNext() ? elements.next() : null;
third = elements.hasNext() ? elements.next() : null;
prev.setValue(third);
} else {
first = elements.next();
second = elements.hasNext() ? elements.next() : null;
third = elements.hasNext() ? elements.next() : null;
}
isFirst.setFalse();
} else {
break;
}
}
action.accept(first, second, third);
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
complette(futureList, eHolder, (E) null);
}
@Override
A[] toArray(A[] a) {
return elements.toArray(a);
}
@Override
public > M toMap(final Function keyExtractor, final Function valueMapper,
final BinaryOperator mergeFunction, final Supplier mapFactory) {
if (maxThreadNum <= 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 List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
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 List>> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
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 List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
return super.reduce(identity, accumulator);
}
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
return super.reduce(accumulator);
}
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
for (int i = 0; i < maxThreadNum; i++) {
futureList.add(asyncExecutor.execute(new Callable() {
@Override
public T call() {
T result = (T) NONE;
T next = null;
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
} else {
break;
}
}
result = result == NONE ? next : 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) {
return super.reduce(identity, accumulator, combiner);
}
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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) {
return super.collect(supplier, accumulator, combiner);
}
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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(final 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 List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
for (int i = 0; i < maxThreadNum; 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 (elements.hasNext()) {
next = elements.next();
} 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 (elements.hasNext() == false) {
return Optional.empty();
} else if (sorted && isSameComparator(comparator, cmp)) {
return Optional.of(elements.next());
}
comparator = comparator == null ? NATURAL_COMPARATOR : comparator;
return collect(Collectors.minBy(comparator));
}
@Override
public Optional max(Comparator comparator) {
if (elements.hasNext() == false) {
return Optional.empty();
} else if (sorted && isSameComparator(comparator, cmp)) {
T next = null;
while (elements.hasNext()) {
next = elements.next();
}
return Optional.of(next);
}
comparator = comparator == null ? NATURAL_COMPARATOR : comparator;
return collect(Collectors.maxBy(comparator));
}
@Override
public long count() {
return elements.count();
}
@Override
public boolean anyMatch(final Try.Predicate predicate) throws E {
if (maxThreadNum <= 1) {
return super.anyMatch(predicate);
}
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
final MutableBoolean result = MutableBoolean.of(false);
for (int i = 0; i < maxThreadNum; i++) {
futureList.add(asyncExecutor.execute(new Runnable() {
@Override
public void run() {
T next = null;
try {
while (result.isFalse() && eHolder.value() == null) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
} 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) {
return super.allMatch(predicate);
}
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
final MutableBoolean result = MutableBoolean.of(true);
for (int i = 0; i < maxThreadNum; i++) {
futureList.add(asyncExecutor.execute(new Runnable() {
@Override
public void run() {
T next = null;
try {
while (result.isTrue() && eHolder.value() == null) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
} 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) {
return super.noneMatch(predicate);
}
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
final MutableBoolean result = MutableBoolean.of(true);
for (int i = 0; i < maxThreadNum; i++) {
futureList.add(asyncExecutor.execute(new Runnable() {
@Override
public void run() {
T next = null;
try {
while (result.isTrue() && eHolder.value() == null) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
} 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 Optional findFirst(final Try.Predicate predicate) throws E {
if (maxThreadNum <= 1) {
return super.findFirst(predicate);
}
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
final Holder> resultHolder = new Holder<>();
final MutableLong index = MutableLong.of(0);
for (int i = 0; i < maxThreadNum; i++) {
futureList.add(asyncExecutor.execute(new Runnable() {
@Override
public void run() {
final Pair pair = new Pair<>();
try {
while (resultHolder.value() == null && eHolder.value() == null) {
synchronized (elements) {
if (elements.hasNext()) {
pair.left = index.getAndIncrement();
pair.right = elements.next();
} else {
break;
}
}
if (predicate.test(pair.right)) {
synchronized (resultHolder) {
if (resultHolder.value() == null || pair.left < resultHolder.value().left) {
resultHolder.setValue(pair.copy());
}
}
break;
}
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
complette(futureList, eHolder, (E) null);
return resultHolder.value() == null ? (Optional) Optional.empty() : Optional.of(resultHolder.value().right);
}
@Override
public Optional findLast(final Try.Predicate predicate) throws E {
if (maxThreadNum <= 1) {
return super.findLast(predicate);
}
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
final Holder> resultHolder = new Holder<>();
final MutableLong index = MutableLong.of(0);
for (int i = 0; i < maxThreadNum; i++) {
futureList.add(asyncExecutor.execute(new Runnable() {
@Override
public void run() {
final Pair pair = new Pair<>();
try {
while (eHolder.value() == null) {
synchronized (elements) {
if (elements.hasNext()) {
pair.left = index.getAndIncrement();
pair.right = elements.next();
} else {
break;
}
}
if (predicate.test(pair.right)) {
synchronized (resultHolder) {
if (resultHolder.value() == null || pair.left > resultHolder.value().left) {
resultHolder.setValue(pair.copy());
}
}
}
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
complette(futureList, eHolder, (E) null);
return resultHolder.value() == null ? (Optional) Optional.empty() : Optional.of(resultHolder.value().right);
}
@Override
public Optional findAny(final Try.Predicate predicate) throws E {
if (maxThreadNum <= 1) {
return super.findAny(predicate);
}
final List> futureList = new ArrayList<>(maxThreadNum);
final Holder eHolder = new Holder<>();
final Holder resultHolder = Holder.of((T) NONE);
for (int i = 0; i < maxThreadNum; i++) {
futureList.add(asyncExecutor.execute(new Runnable() {
@Override
public void run() {
T next = null;
try {
while (resultHolder.value() == NONE && eHolder.value() == null) {
synchronized (elements) {
if (elements.hasNext()) {
next = elements.next();
} else {
break;
}
}
if (predicate.test(next)) {
synchronized (resultHolder) {
if (resultHolder.value() == NONE) {
resultHolder.setValue(next);
}
}
break;
}
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
complette(futureList, eHolder, (E) null);
return resultHolder.value() == NONE ? (Optional) Optional.empty() : Optional.of(resultHolder.value());
}
@Override
public Stream intersection(final Function mapper, final Collection c) {
if (maxThreadNum <= 1) {
super.intersection(mapper, c);
}
final Multiset multiset = Multiset.from(c);
return filter(new Predicate() {
@Override
public boolean test(T value) {
final Object key = mapper.apply(value);
synchronized (multiset) {
return multiset.getAndRemove(key) > 0;
}
}
});
}
@Override
public Stream difference(final Function mapper, final Collection c) {
if (maxThreadNum <= 1) {
return super.intersection(mapper, c);
}
final Multiset multiset = Multiset.from(c);
return filter(new Predicate() {
@Override
public boolean test(T value) {
final Object key = mapper.apply(value);
synchronized (multiset) {
return multiset.getAndRemove(key) < 1;
}
}
});
}
@Override
public Stream append(Stream stream) {
return new ParallelIteratorStream<>(Stream.concat(this, stream), false, null, maxThreadNum, splitor, closeHandlers);
}
@Override
public Stream prepend(Stream stream) {
return new ParallelIteratorStream<>(Stream.concat(stream, this), false, null, maxThreadNum, splitor, closeHandlers);
}
@Override
public Stream merge(final Stream b, final BiFunction nextSelector) {
return new ParallelIteratorStream<>(Stream.merge(this, b, nextSelector), false, null, maxThreadNum, splitor, closeHandlers);
}
@Override
public Stream zipWith(Stream b, BiFunction zipFunction) {
return new ParallelIteratorStream<>(Stream.zip(this, b, zipFunction), false, null, maxThreadNum, splitor, closeHandlers);
}
@Override
public