MapValueSet

package Base;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

public class MapValueSet<K,T> {

    Indexer indxK = new Indexer();
    Indexer indxT = new Indexer();

    Map<K,Integer> kTags = new HashMap<K,Integer>();
    Map<T,Integer> tTags = new HashMap<T,Integer>();

    Map<Integer,HashSet<Integer>> MapK = new HashMap<Integer,HashSet<Integer>>();

    Map<Integer,HashSet<Integer>> MapT = new HashMap<Integer,HashSet<Integer>>();

    public void put(K k, T t){

        if(!kTags.containsKey(k)){
            kTags.put(k, indxK.getNextTag());
        }

        if(!MapK.containsKey(kTags.get(k))){
            MapK.put(kTags.get(k), new HashSet<Integer>());
        }

        if(!tTags.containsKey(t)){
            tTags.put(t, indxT.getNextTag());
        }

        if(!MapT.containsKey(tTags.get(t))){
            MapT.put(tTags.get(t), new HashSet<Integer>());
        }
            MapK.get(kTags.get(k)).add(tTags.get(t));
            MapT.get(tTags.get(t)).add(kTags.get(k));
    }

    public boolean removeAtKey(K k, T t){
        int kTag = -1;
        int tTag = -1;

        if(kTags.get(k) != null){
        kTag = kTags.get(k);
        }

        if(tTags.get(t) != null){
        tTag = tTags.get(t);
        }

        if(kTag == -1 || tTag == -1){
            System.out.println("Keys are Blank at: removeAtKey(k,t)");
            return false;
        }

        boolean removed = false;

            if(MapK.get(kTag) != null){
                removed = MapK.get(kTag).remove(tTag);
            }
            if(MapT.get(tTag) != null){
                MapT.get(tTag).remove(kTag);
            }

            if(!MapK.containsKey(kTag)){
                kTags.remove(k);
                indxK.removeTag(kTag);
            }

            if(MapK.containsKey(kTag)){
                tTags.remove(t);
                indxT.removeTag(tTag);

            }

        return removed;
    }

    public void removeAtValue(T t){
        if(!tTags.containsKey(t)){
            return;
        }
        Object[] keyArr = MapT.get(tTags.get(t)).toArray();

        for(int i = 0; i < keyArr.length; i++){
            MapK.get(keyArr[i]).remove(tTags.get(t));
        }

            indxT.removeTag(tTags.get(t));
            MapT.remove(tTags.get(t));
            tTags.remove(t);
    }

    public boolean mapContains(T t){
        if(tTags.get(t) == null){
            return false;
        }
        int tTag = tTags.get(t);

        return MapT.get(tTag) != null && !MapT.get(tTag).isEmpty();
    }

    public boolean containsKey(K k){

        if(kTags.get(k) == null){
            return false;
        }

        return MapK.containsKey(kTags.get(k));
    }

    public boolean keyContains(K k, T t){

        if(kTags.get(k) != null && tTags.get(t) != null){
            return MapK.get(kTags.get(k)).contains(tTags.get(t));
        }

        return false;

    }

    @Override
    public String toString(){

        String s = "";

        s = s+ "Key      Map: " + MapK.toString() + "\n";
        s = s+ "Value    Map: " + MapT.toString() + "\n";
        s = s+ "KeyTag   Map: " + kTags.toString() + "\n";
        s = s+ "ValueTag Map: " + tTags.toString() + "\n";
        s = s+ "KeyTag   List: " + indxK.activeSet().toString() + "\n";
        s = s+ "ValueTag List: " + indxT.activeSet().toString();

        return s;
    }


}