org.rx.core.NQuery Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of rxlib Show documentation
Show all versions of rxlib Show documentation
A set of utilities for Java
package org.rx.core;
import com.google.common.collect.Iterables;
import com.google.common.collect.Streams;
import io.netty.util.internal.ThreadLocalRandom;
import lombok.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.IterableUtils;
import org.apache.commons.collections4.IteratorUtils;
import org.rx.annotation.ErrorCode;
import org.rx.bean.$;
import org.rx.bean.Decimal;
import org.rx.exception.ApplicationException;
import org.rx.exception.InvalidException;
import org.rx.util.function.*;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.util.*;
import java.util.Collections;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import static org.rx.bean.$.$;
import static org.rx.core.Constants.NON_RAW_TYPES;
import static org.rx.core.Constants.NON_UNCHECKED;
import static org.rx.core.Extends.*;
/**
* https://msdn.microsoft.com/en-us/library/bb738550(v=vs.110).aspx
*/
@Slf4j
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public final class NQuery implements Iterable, Serializable {
private static final long serialVersionUID = -7167070585936243198L;
//region staticMembers
public static boolean couldBeCollection(Class type) {
return Iterable.class.isAssignableFrom(type)
|| type.isArray()
|| Iterator.class.isAssignableFrom(type);
}
@SuppressWarnings(NON_UNCHECKED)
@ErrorCode
public static List asList(@NonNull Object collection, boolean throwOnFail) {
Iterable iterable;
if ((iterable = as(collection, Iterable.class)) != null) {
return IterableUtils.toList(iterable);
}
Class type = collection.getClass();
if (type.isArray()) {
int length = Array.getLength(collection);
List list = new ArrayList<>(length);
for (int i = 0; i < length; i++) {
list.add((T) Array.get(collection, i));
}
return list;
}
Iterator iterator;
if ((iterator = as(collection, Iterator.class)) != null) {
return IteratorUtils.toList(iterator);
}
if (throwOnFail) {
throw new ApplicationException(values(type.getSimpleName()));
}
ArrayList list = new ArrayList<>();
list.add((T) collection);
return list;
}
public static NQuery ofCollection(Object collection) {
return new NQuery<>(asList(collection, true), false);
}
public static NQuery of(T one) {
return of(Arrays.toList(one));
}
@SafeVarargs
public static NQuery of(T... array) {
return of(Arrays.toList(array));
}
public static NQuery of(@NonNull Stream stream) {
return of(stream::iterator, stream.isParallel());
}
public static NQuery of(Iterable iterable) {
return of(iterable, false);
}
public static NQuery of(Iterable iterable, boolean isParallel) {
if (iterable == null) {
iterable = Collections.emptyList();
}
return new NQuery<>(iterable, isParallel);
}
//endregion
//region Member
private final Iterable data;
private final boolean isParallel;
public Stream stream() {
return StreamSupport.stream(data.spliterator(), isParallel);
}
private List newList() {
int count = count();
return isParallel ? newConcurrentList(count, false) : new ArrayList<>(count);
}
private Set newSet() {
int count = count();
return isParallel ? Collections.synchronizedSet(new LinkedHashSet<>(count)) : new LinkedHashSet<>(count);
}
private Map newMap() {
int count = count();
return isParallel ? Collections.synchronizedMap(new LinkedHashMap<>(count)) : new LinkedHashMap<>(count);
}
private Stream newStream(Iterable iterable) {
return StreamSupport.stream(iterable.spliterator(), isParallel);
}
private NQuery me(Iterable set) {
return of(set, isParallel);
}
private NQuery me(Stream stream) {
return me(stream.collect(Collectors.toList()));
}
@SneakyThrows
private NQuery me(EachFunc func, String prevMethod) {
if (isParallel) {
log.warn("Not supported parallel {}", prevMethod);
}
Spliterator spliterator = data.spliterator();
Stream r = StreamSupport.stream(new Spliterators.AbstractSpliterator(spliterator.estimateSize(), spliterator.characteristics()) {
final AtomicBoolean breaker = new AtomicBoolean();
final AtomicInteger counter = new AtomicInteger();
@Override
public boolean tryAdvance(Consumer action) {
return spliterator.tryAdvance(p -> {
int flags = func.each(p, counter.getAndIncrement());
if ((flags & EachFunc.ACCEPT) == EachFunc.ACCEPT) {
action.accept(p);
}
if ((flags & EachFunc.BREAK) == EachFunc.BREAK) {
breaker.set(true);
}
}) && !breaker.get();
}
}, isParallel);
return me(r);
}
@FunctionalInterface
interface EachFunc {
int NONE = 0;
int ACCEPT = 1;
int BREAK = 1 << 1;
int each(T item, int index);
}
//endregion
@Override
public Iterator iterator() {
return data.iterator();
}
@Override
public void forEach(Consumer action) {
stream().forEach(action);
}
public void forEachOrdered(Consumer action) {
stream().forEachOrdered(action);
}
public NQuery select(BiFunc selector) {
return me(stream().map(selector.toFunction()));
}
public NQuery select(BiFuncWithIndex selector) {
AtomicInteger counter = new AtomicInteger();
return me(stream().map(p -> {
try {
return selector.invoke(p, counter.getAndIncrement());
} catch (Throwable e) {
throw InvalidException.sneaky(e);
}
}));
}
public NQuery selectMany(BiFunc> selector) {
return me(stream().flatMap(p -> newStream(sneakyInvoke(() -> selector.invoke(p)))));
}
public NQuery selectMany(BiFuncWithIndex> selector) {
AtomicInteger counter = new AtomicInteger();
return me(stream().flatMap(p -> newStream(sneakyInvoke(() -> selector.invoke(p, counter.getAndIncrement())))));
}
public NQuery where(PredicateFunc predicate) {
return me(stream().filter(p -> {
try {
return predicate.invoke(p);
} catch (Throwable e) {
throw InvalidException.sneaky(e);
}
}));
}
public NQuery where(PredicateFuncWithIndex predicate) {
AtomicInteger counter = new AtomicInteger();
return me(stream().filter(p -> {
try {
return predicate.invoke(p, counter.getAndIncrement());
} catch (Throwable e) {
throw InvalidException.sneaky(e);
}
}));
}
public NQuery join(Iterable inner, BiPredicate keySelector, BiFunction resultSelector) {
return me(stream().flatMap(p -> newStream(inner).filter(p2 -> keySelector.test(p, p2)).map(p3 -> resultSelector.apply(p, p3))));
}
public NQuery join(BiFunc innerSelector, BiPredicate keySelector, BiFunction resultSelector) {
return join(stream().map(innerSelector.toFunction()).collect(Collectors.toList()), keySelector, resultSelector);
}
public NQuery joinMany(BiFunc> innerSelector, BiPredicate keySelector, BiFunction resultSelector) {
return join(stream().flatMap(p -> newStream(sneakyInvoke(() -> innerSelector.invoke(p)))).collect(Collectors.toList()), keySelector, resultSelector);
}
public NQuery leftJoin(Iterable inner, BiPredicate keySelector, BiFunction resultSelector) {
return me(stream().flatMap(p -> {
if (!newStream(inner).anyMatch(p2 -> keySelector.test(p, p2))) {
return Stream.of(resultSelector.apply(p, null));
}
return newStream(inner).filter(p2 -> keySelector.test(p, p2)).map(p3 -> resultSelector.apply(p, p3));
}));
}
public NQuery leftJoin(BiFunc innerSelector, BiPredicate keySelector, BiFunction resultSelector) {
return leftJoin(stream().map(innerSelector.toFunction()).collect(Collectors.toList()), keySelector, resultSelector);
}
public NQuery leftJoinMany(BiFunc> innerSelector, BiPredicate keySelector, BiFunction resultSelector) {
return leftJoin(stream().flatMap(p -> newStream(sneakyInvoke(() -> innerSelector.invoke(p)))).collect(Collectors.toList()), keySelector, resultSelector);
}
public boolean all(PredicateFunc predicate) {
return stream().allMatch(predicate.toPredicate());
}
public boolean any() {
return stream().findAny().isPresent();
}
public boolean any(PredicateFunc predicate) {
return stream().anyMatch(predicate.toPredicate());
}
public boolean contains(T item) {
return stream().anyMatch(p -> p.equals(item));
}
public NQuery concat(Iterable set) {
return me(Stream.concat(stream(), newStream(set)));
}
public NQuery distinct() {
return me(stream().distinct());
}
public NQuery except(Iterable set) {
return me(stream().filter(p -> !newStream(set).anyMatch(p2 -> p2.equals(p))));
}
public NQuery intersection(Iterable set) {
return me(stream().filter(p -> newStream(set).anyMatch(p2 -> p2.equals(p))));
}
public NQuery difference(Iterable set) {
return NQuery.of(CollectionUtils.disjunction(this, set));
}
public NQuery union(Iterable set) {
return NQuery.of(CollectionUtils.union(this, set));
}
public NQuery orderByRand() {
return me(stream().sorted(getComparator(p -> ThreadLocalRandom.current().nextInt(0, 100))));
}
public NQuery orderBy(BiFunc keySelector) {
// return me(stream().sorted(Comparator.nullsLast(Comparator.comparing((Function) keySelector.toFunction()))));
return me(stream().sorted(getComparator(keySelector)));
}
@SuppressWarnings(NON_RAW_TYPES)
public static Comparator getComparator(BiFunc keySelector) {
return (p1, p2) -> {
try {
Comparable c1 = as(keySelector.invoke(p1), Comparable.class);
Comparable c2 = as(keySelector.invoke(p2), Comparable.class);
if (c1 == null || c2 == null) {
return c1 == null ? (c2 == null ? 0 : 1) : -1;
}
return c1.compareTo(c2);
} catch (Throwable e) {
throw InvalidException.sneaky(e);
}
};
}
public NQuery orderByDescending(BiFunc keySelector) {
return me(stream().sorted(getComparator(keySelector).reversed()));
}
public NQuery orderByMany(BiFunc> keySelector) {
return me(stream().sorted(getComparatorMany(keySelector)));
}
@SuppressWarnings(NON_RAW_TYPES)
public static Comparator getComparatorMany(BiFunc> keySelector) {
return (p1, p2) -> {
try {
List