cyclops.collections.vavr.VavrTreeSetX Maven / Gradle / Ivy
package cyclops.collections.vavr;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Optional;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;
import com.aol.cyclops2.data.collections.extensions.CollectionX;
import com.aol.cyclops2.data.collections.extensions.lazy.immutable.LazyPOrderedSetX;
import com.aol.cyclops2.types.Unwrapable;
import com.aol.cyclops2.types.foldable.Evaluation;
import cyclops.collections.immutable.OrderedSetX;
import cyclops.collections.immutable.VectorX;
import cyclops.function.Reducer;
import cyclops.stream.ReactiveSeq;
import org.jooq.lambda.tuple.Tuple2;
import org.pcollections.POrderedSet;
import io.vavr.collection.SortedSet;
import io.vavr.collection.TreeSet;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.experimental.Wither;
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class VavrTreeSetX extends AbstractSetimplements POrderedSet, Unwrapable {
public static OrderedSetX treeSetX(ReactiveSeq stream, Comparator c){
return fromStream(stream,c);
}
public static > OrderedSetX treeSetX(ReactiveSeq stream){
return fromStream(stream);
}
public static OrderedSetX copyFromCollection(CollectionX vec, Comparator comp) {
return VavrTreeSetX.empty(comp)
.plusAll(vec);
}
@Override
public R unwrap() {
return (R)set;
}
/**
* Create a LazyPOrderedSetX from a Stream
*
* @param stream to construct a LazyQueueX from
* @return LazyPOrderedSetX
*/
public static > LazyPOrderedSetX fromStream(Stream stream) {
return new LazyPOrderedSetX(null,ReactiveSeq.fromStream(stream), toPOrderedSet(), Evaluation.LAZY);
}
public static LazyPOrderedSetX fromStream(Stream stream,Comparator c) {
return new LazyPOrderedSetX(null,ReactiveSeq.fromStream(stream), toPOrderedSet(c), Evaluation.LAZY);
}
/**
* Create a LazyPOrderedSetX that contains the Integers between start and end
*
* @param start
* Number of range to start from
* @param end
* Number for range to end at
* @return Range ListX
*/
public static LazyPOrderedSetX range(int start, int end) {
return fromStream(ReactiveSeq.range(start, end));
}
/**
* Create a LazyPOrderedSetX that contains the Longs between start and end
*
* @param start
* Number of range to start from
* @param end
* Number for range to end at
* @return Range ListX
*/
public static LazyPOrderedSetX rangeLong(long start, long end) {
return fromStream(ReactiveSeq.rangeLong(start, end));
}
/**
* Unfold a function into a ListX
*
*
* {@code
* LazyPOrderedSetX.unfold(1,i->i<=6 ? Optional.of(Tuple.tuple(i,i+1)) : Optional.empty());
*
* //(1,2,3,4,5)
*
* }
*
* @param seed Initial value
* @param unfolder Iteratively applied function, terminated by an empty Optional
* @return ListX generated by unfolder function
*/
public static > LazyPOrderedSetX unfold(U seed, Function>> unfolder) {
return fromStream(ReactiveSeq.unfold(seed, unfolder));
}
/**
* Generate a LazyPOrderedSetX from the provided Supplier up to the provided limit number of times
*
* @param limit Max number of elements to generate
* @param s Supplier to generate ListX elements
* @return ListX generated from the provided Supplier
*/
public static > LazyPOrderedSetX generate(long limit, Supplier s) {
return fromStream(ReactiveSeq.generate(s)
.limit(limit));
}
/**
* Create a LazyPOrderedSetX by iterative application of a function to an initial element up to the supplied limit number of times
*
* @param limit Max number of elements to generate
* @param seed Initial element
* @param f Iteratively applied to each element to generate the next element
* @return ListX generated by iterative application
*/
public static > LazyPOrderedSetX iterate(long limit, final T seed, final UnaryOperator f) {
return fromStream(ReactiveSeq.iterate(seed, f)
.limit(limit));
}
/**
*
* {@code
* POrderedSet q = VavrTreeSetX.toPOrderedSet()
.mapReduce(Stream.of(1,2,3,4));
*
* }
*
* @return Reducer for POrderedSet
*/
public static > Reducer> toPOrderedSet() {
return Reducer.> of(VavrTreeSetX.emptyPOrderedSet(), (final POrderedSet a) -> b -> a.plusAll(b),
(final T x) -> VavrTreeSetX.singleton(x));
}
public static Reducer> toPOrderedSet(Comparator comparator) {
return Reducer.> of(VavrTreeSetX.emptyPOrderedSet(comparator), (final POrderedSet a) -> b -> a.plusAll(b),
(final T x) -> VavrTreeSetX.singleton(comparator,x));
}
public static > VavrTreeSetX emptyPOrderedSet() {
return new VavrTreeSetX(TreeSet.empty());
}
public static VavrTreeSetX emptyPOrderedSet(Comparator comparator) {
return new VavrTreeSetX(TreeSet.empty(comparator));
}
public static > LazyPOrderedSetX empty() {
return fromPOrderedSet(new VavrTreeSetX(
TreeSet.empty()),toPOrderedSet());
}
private static LazyPOrderedSetX fromPOrderedSet(POrderedSet ordered, Reducer> reducer) {
return new LazyPOrderedSetX(ordered,null,reducer, Evaluation.LAZY);
}
public static LazyPOrderedSetX empty(Comparator comparator) {
return fromPOrderedSet(new VavrTreeSetX(
TreeSet.empty(comparator)),toPOrderedSet(comparator));
}
public static > LazyPOrderedSetX singleton(T t) {
return fromPOrderedSet(new VavrTreeSetX<>(
TreeSet.of(t)),toPOrderedSet());
}
public static LazyPOrderedSetX singleton(Comparator comparator,T t) {
return fromPOrderedSet(new VavrTreeSetX(
TreeSet.of(comparator,t)),toPOrderedSet(comparator));
}
public static > LazyPOrderedSetX of(T... t) {
return fromPOrderedSet(new VavrTreeSetX<>(
TreeSet.of(t)),toPOrderedSet());
}
public static LazyPOrderedSetX ofAll(SortedSet set) {
return fromPOrderedSet(new VavrTreeSetX<>(set), toPOrderedSet(set.comparator()));
}
public static LazyPOrderedSetX POrderedSet(SortedSet set) {
return fromPOrderedSet(new VavrTreeSetX<>(set), toPOrderedSet(set.comparator()));
}
public static > LazyPOrderedSetX POrderedSet(T... elements) {
return fromPOrderedSet(of(elements), toPOrderedSet());
}
@Wither
private final SortedSet set;
@Override
public POrderedSet plus(T e) {
return withSet(set.add(e));
}
@Override
public POrderedSet plusAll(Collection l) {
return withSet(set.addAll(l));
}
@Override
public POrderedSet minus(Object e) {
return withSet(set.remove((T) e));
}
@Override
public POrderedSet minusAll(Collection l) {
return withSet(set.removeAll((Collection) l));
}
@Override
public int size() {
return set.size();
}
@Override
public Iterator iterator() {
return set.iterator();
}
@Override
public T get(int index) {
if (index > set.size() || index < 0)
throw new IndexOutOfBoundsException();
T result = set.get();
for (int i = 0; i < index; i++) {
result = set.get();
}
return result;
}
@Override
public int indexOf(Object o) {
return set.toStream()
.zipWithIndex()
.find(t -> t._1.equals(o))
.map(t -> t._2)
.getOrElse(-1)
.intValue();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy