cyclops.collections.vavr.VavrBitSetX Maven / Gradle / Ivy

Go to download
package cyclops.collections.vavr;


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.function.Reducer;
import cyclops.stream.ReactiveSeq;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.experimental.Wither;
import org.jooq.lambda.tuple.Tuple2;
import org.pcollections.POrderedSet;
import io.vavr.collection.BitSet;

import java.util.*;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;

/*
 * BitSet is experimental / not ready for prime time
 */
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class VavrBitSetX extends AbstractSetimplements POrderedSet, Unwrapable {

    public static OrderedSetX bitSetX(ReactiveSeq stream){
        return fromStream(stream);
    }

    @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) {
        Reducer> reducer = VavrBitSetX.toPOrderedSet();
        return new LazyPOrderedSetX( null, ReactiveSeq.fromStream(stream),
                                  reducer, 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 SetX
     */
    public static LazyPOrderedSetX range(int start, int end) {
        return fromStream(ReactiveSeq.range(start, end));
    }

   

    /**
     * Unfold a function into a SetX
     * 
     *      * {@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 SetX generated by unfolder function
     */
    public static  LazyPOrderedSetX unfold(Integer 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 SetX elements
     * @return SetX 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 SetX 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 = JSPOrderedSet.toPOrderedSet()
                                     .mapReduce(Stream.of(1,2,3,4));
     * 
     * }
     * 
     * @return Reducer for POrderedSet
     */
    public static  Reducer> toPOrderedSet() {
        return Reducer.> of(VavrBitSetX.emptyPOrderedSet(),
                                                 (final POrderedSet a) -> b -> a.plusAll(b),
                                      (final Integer x) -> VavrBitSetX.singleton(x));
    }
    
  

    public static VavrBitSetX fromSet(BitSet set) {
        return new VavrBitSetX(
                                 set);
    }

    
    public static VavrBitSetX emptyPOrderedSet() {
        return new VavrBitSetX(BitSet.empty());
    }
    
    
    public static LazyPOrderedSetX empty() {
        
        
        return fromPOrderedSet(new VavrBitSetX(BitSet.empty()),
                                                toPOrderedSet());
    }

    public static  LazyPOrderedSetX singleton(Integer t) {
        return of(t);
    }
   
    public static  LazyPOrderedSetX of(Integer... t) {


       BitSet vec = BitSet.of(t);
       return fromPOrderedSet(new VavrBitSetX(
                                                       vec),
                                     toPOrderedSet());
   }



    private static  LazyPOrderedSetX fromPOrderedSet(POrderedSet ordered, Reducer> reducer) {
        return  new LazyPOrderedSetX(ordered,null,reducer, Evaluation.LAZY);
    }
    public static  LazyPOrderedSetX POrderedSet(BitSet q) {
        return fromPOrderedSet(new VavrBitSetX(
                                                         q),
                                      toPOrderedSet());
    }

    @SafeVarargs
    public static  LazyPOrderedSetX POrderedSet(Integer... elements) {
        return fromPOrderedSet(of(elements), toPOrderedSet());
    }

    @Wither
    private final BitSet set;

    @Override
    public VavrBitSetX plus(Integer e) {
       
        return withSet(set.add((int)e));
    }

    @Override
    public VavrBitSetX plusAll(Collection l) {
        
        
        BitSet vec = set.addAll(l);


        return withSet(vec);
       
    }

   

    
  

    @Override
    public POrderedSet minus(Object e) {
        if(e instanceof Integer){
            Integer i =(Integer)e;
            return withSet((BitSet)set.remove((int)i));
        }
        else
            return this;
                
    }

    @Override
    public POrderedSet minusAll(Collection s) {

        return withSet((BitSet)set.removeAll(s));
    }

  
   

    @Override
    public int size() {
        return set.size();
    }

    @Override
    public io.vavr.collection.Iterator iterator() {
        return set.iterator();
    }

    @Override
    public Integer get(int index) {
        return (Integer) set.toVector().apply(index);
    }

    @Override
    public int indexOf(Object o) {
        return set.toVector().indexOf(o);
    }





    public static OrderedSetX copyFromCollection(CollectionX vec) {
        OrderedSetX res = VavrBitSetX.empty()
                .plusAll(vec);
        return res;
    }

}