cyclops.collections.clojure.ClojureArrayMapX Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of cyclops-clojure Show documentation
Clojure Collections
The newest version!
package cyclops.collections.clojure;

import clojure.lang.PersistentArrayMap;
import clojure.lang.PersistentVector;
import com.aol.cyclops2.data.collections.extensions.ExtensiblePMapX;
import com.aol.cyclops2.types.mixins.TupleWrapper;
import cyclops.collections.immutable.PersistentMapX;
import cyclops.companion.MapXs;
import cyclops.control.Eval;
import cyclops.function.Reducer;
import cyclops.stream.ReactiveSeq;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.NonNull;
import lombok.experimental.Wither;
import org.jooq.lambda.tuple.Tuple2;
import org.pcollections.PMap;

import java.util.*;
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class ClojureArrayMapX extends AbstractMap implements PMap{
    
    @Wither
    PersistentArrayMap map;
    public static  Reducer> toPersistentMapX() {
        return Reducer.> of(empty(), (final PersistentMapX a) -> b -> a.plusAll(b), (in) -> {
            final List w = ((TupleWrapper) () -> in).values();
            return singleton((K) w.get(0), (V) w.get(1));
        });
    }
    public static  ClojureArrayMapX fromMap(@NonNull PersistentArrayMap map){
        return new ClojureArrayMapX<>(map);
    }
    public static  ClojureArrayMapX fromJavaMap(@NonNull Map map){
        PersistentArrayMap res = ( PersistentArrayMap)PersistentArrayMap.create(map);
        return fromMap(res);
    }
    public static  ClojureArrayMapX emptyPMap(){
        return fromMap(PersistentArrayMap.EMPTY);
     }
    public static  PersistentMapX empty(){
       return new ExtensiblePMapX(new ClojureArrayMapX<>(PersistentArrayMap.EMPTY),Eval.later(()->toPersistentMapX()));
    }
    public static  PMap singletonPMap(K key,V value){
        PersistentArrayMap map = ( PersistentArrayMap)PersistentArrayMap.create(MapXs.of(key, value));
        return fromMap(map);
     }
    public static  PersistentMapX singleton(K key,V value){
        PersistentArrayMap map = ( PersistentArrayMap)PersistentArrayMap.create(MapXs.of(key, value));
        return new ExtensiblePMapX(fromMap(map), Eval.later(()-> ClojureArrayMapX.toPersistentMapX()));
     }
    
    public static  PersistentMapX fromStream(@NonNull ReactiveSeq> stream){
        return stream.mapReduce(toPersistentMapX());
    }
    
    @Override
    public PMap plus(K key, V value) {
        return withMap((PersistentArrayMap)map.cons(PersistentVector.create(key,value)));
    }
    @Override
    public PMap plusAll(java.util.Map m2) {
        PersistentArrayMap m = map;
        for(Object next : m2.entrySet()){
            m = (PersistentArrayMap)m.cons(next);
        }
        return withMap(m);
    }
    @Override
    public PMap minus(Object key) {
      
        
        return withMap((PersistentArrayMap)map.without(key));
     
    }
   
    @Override
    public PMap minusAll(Collection keys) {
      
       PersistentArrayMap m = map;
       for(Object key : keys){
          
           m = (PersistentArrayMap)m.without(key);
       }
       return withMap(m);
        
    }
    @Override
    public Set> entrySet() {
        return map.entrySet();
        
    }
    /* (non-Javadoc)
     * @see java.util.AbstractMap#get(java.lang.Object)
     */
    @Override
    public V get(Object key) {
       return (V)map.valAt(key);
    }
   
    
   
   
}