package tc.oc.commons.core.util;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Random;
import java.util.function.BiFunction;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.Consumer;
import java.util.function.IntSupplier;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import javax.annotation.Nullable;
import com.google.common.collect.Lists;
import tc.oc.commons.core.IterableUtils;
public final class Streams {
private Streams() {}
private static final Consumer NO_OP = o -> {};
public static void consume(Stream<?> stream) {
stream.forEach(NO_OP);
}
public static <T> Stream<T> reverseStream(Iterable<T> iterable) {
return Lists.reverse(Lists.newArrayList(iterable)).stream();
}
public static <T, E extends Throwable> void forEachThrows(Stream<T> stream, ThrowingConsumer<? super T, E> consumer) throws E {
for(final Iterator<T> it = stream.iterator(); it.hasNext();) {
consumer.acceptThrows(it.next());
}
}
public static <T> void forEachWithIndex(Stream<T> stream, IndexedConsumer<T> consumer) {
final Counter index = new Counter();
stream.forEachOrdered(t -> consumer.accept(t, index.next()));
}
public static <T> Stream<T> reverse(Stream<T> stream) {
return Lists.reverse(stream.collect(Collectors.toCollection(ArrayList::new))).stream();
}
public static <T> void reverseForEach(Stream<T> stream, Consumer<? super T> consumer) {
reverse(stream).forEach(consumer);
}
public static <T, E extends Throwable> void reverseForEachThrows(Stream<T> stream, ThrowingConsumer<? super T, E> consumer) throws E {
forEachThrows(reverse(stream), consumer);
}
public static <T> Stream<T> shuffle(Stream<T> stream, Random random) {
final List<T> list = stream.collect(Collectors.toCollection(ArrayList::new));
Collections.shuffle(list, random);
return list.stream();
}
public static <T> Stream<T> shuffle(Stream<T> stream) {
final List<T> list = stream.collect(Collectors.toCollection(ArrayList::new));
Collections.shuffle(list);
return list.stream();
}
public static <T> Stream<T> flatten(Stream<Stream<? extends T>> streams) {
return (Stream<T>) streams.reduce(Stream::concat)
.orElse(Stream.of());
}
public static <T> Stream<T> concat(Stream<? extends T>... streams) {
return flatten(Stream.of(streams));
}
public static <T> Stream<T> instancesOf(Stream<?> stream, Class<T> type) {
return (Stream<T>) stream.filter(type::isInstance);
}
public static <T> Stream<Class<? extends T>> subtypesOf(Stream<? extends Class<?>> stream, Class<T> type) {
return (Stream) stream.filter(type::isAssignableFrom);
}
public static <T> boolean any(Stream<T> stream, Predicate<? super T> predicate) {
return stream.filter(predicate).findAny().isPresent();
}
public static <T> boolean all(Stream<T> stream, Predicate<? super T> predicate) {
return any(stream, predicate.negate());
}
public static <T> boolean none(Stream<T> stream, Predicate<? super T> predicate) {
return !any(stream, predicate);
}
public static <T> Stream<T> copyOf(Stream<T> stream) {
return stream.collect(Collectors.toList()).stream();
}
public static <T> Stream<T> copyOf(Collection<T> collection) {
return IterableUtils.copyOf(collection).stream();
}
public static <T> Stream<T> append(Stream<T> stream, T... elements) {
return Stream.concat(stream, Stream.of(elements));
}
public static <T> Stream<T> prepend(Stream<T> stream, T... elements) {
return Stream.concat(Stream.of(elements), stream);
}
public static <T> Stream<T> remove(Stream<T> stream, T... elements) {
return stream.filter(t -> !ArrayUtils.contains(elements, t));
}
public static <T> Stream<T> of(Iterator<T> iterator) {
return StreamSupport.stream(Spliterators.spliterator(iterator, 0, Spliterator.ORDERED), false);
}
public static <T> Stream<T> of(Iterable<T> iterable) {
if(iterable instanceof Collection) {
return ((Collection<T>) iterable).stream();
} else {
return StreamSupport.stream(iterable.spliterator(), false);
}
}
public static <T> Stream<T> ofNullable(@Nullable T t) {
return t == null ? Stream.empty() : Stream.of(t);
}
public static <T> Stream<T> ofNullables(Stream<T> s) {
return s.filter(t -> t != null);
}
public static <T> Stream<T> ofNullables(T... things) {
return ofNullables(Stream.of(things));
}
public static <T> Stream<T> conditional(boolean condition, Stream<T> stream) {
return condition ? stream : Stream.empty();
}
public static <T> Stream<T> conditional(boolean condition, T element) {
return condition ? Stream.of(element) : Stream.empty();
}
public static <T> Stream<T> conditional(boolean condition, Supplier<? extends T> element) {
return condition ? Stream.of(element.get()) : Stream.empty();
}
public static <T> Stream<T> compact(Stream<Optional<T>> stream) {
return stream.filter(Optional::isPresent).map(Optional::get);
}
public static <T> Stream<T> compact(Optional<T>... elements) {
return compact(Stream.of(elements));
}
public static <T> Stream<T> compact1(T t1, Optional<T>... elements) {
return Stream.concat(Stream.of(t1), compact(Stream.of(elements)));
}
public static <T> Stream<T> compact2(T t1, T t2, Optional<T>... elements) {
return Stream.concat(Stream.of(t1, t2), compact(Stream.of(elements)));
}
public static <T> Stream<T> compact3(T t1, T t2, T t3, Optional<T>... elements) {
return Stream.concat(Stream.of(t1, t2, t3), compact(Stream.of(elements)));
}
public static <T, R> R reduce(Stream<T> stream, R identity, BiFunction<R, T, R> accumulator) {
class Result { R v; }
Result result = new Result();
result.v = identity;
stream.forEachOrdered(t -> result.v = accumulator.apply(result.v, t));
return result.v;
}
/**
* Test if all elements of the stream are equal to each other, according to {@link Objects#equals(Object, Object)}.
* Returns true for an empty stream, or a stream of all nulls.
*/
public static <T> boolean isUniform(Stream<T> stream) {
return stream.reduce(Uniformity.EMPTY, Uniformity::add, Uniformity::combine).isUniform();
}
/**
* This is surprisingly complex, but it is the simplest approach I could come up
* with that is actually in the spirit of streams. This is actually quite efficient,
* creating at most one temporary object per reduction thread.
*/
private interface Uniformity<T> {
boolean isUniform();
Uniformity<T> add(T t);
Uniformity<T> combine(Uniformity<T> that);
// Initial (empty) result
Uniformity EMPTY = new Uniformity() {
@Override public boolean isUniform() { return true; }
@Override public Uniformity add(Object t) { return new Intermediate(t); }
@Override public Uniformity combine(Uniformity that) { return that; }
};
// Result after multiple distinct values have been seen
Uniformity FAILED = new Uniformity() {
@Override public boolean isUniform() { return false; }
@Override public Uniformity add(Object t) { return this; }
@Override public Uniformity combine(Uniformity that) { return this; }
};
// Result after one or more values have been seen, and they are all equal
class Intermediate<T> implements Uniformity<T> {
final T value;
public Intermediate(T value) {
this.value = value;
}
@Override public boolean isUniform() {
return true;
}
@Override public Uniformity<T> add(T t) {
return Objects.equals(value, t) ? this : FAILED;
}
@Override public Uniformity<T> combine(Uniformity<T> that) {
if(that instanceof Intermediate) {
return add(((Intermediate<T>) that).value);
} else {
return that.combine(this);
}
}
}
}
}