the great move

forge-core/src/main/java/forge/util/maps/EnumMapOfLists.java

@@ -0,0 +1,51 @@
+package forge.util.maps;
+
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.base.Supplier;
+
+public class EnumMapOfLists<K extends Enum<K>, V> extends EnumMap<K, Collection<V>> implements MapOfLists<K, V> {
+    private final Supplier<? extends Collection<V>> factory;
+    
+    private static final long serialVersionUID = 4107133987205594272L;
+
+    public EnumMapOfLists(Class<K> keyType, Supplier<? extends Collection<V>> factory) {
+        super(keyType);
+        this.factory = factory;
+    }
+
+
+    public EnumMapOfLists(EnumMap<K, ? extends List<V>> m, Supplier<? extends Collection<V>> factory) {
+        super(m);
+        this.factory = factory;
+    }
+
+    public EnumMapOfLists(Map<K, ? extends List<V>> m, Supplier<? extends Collection<V>> factory) {
+        super(m);
+        this.factory = factory;
+    }
+
+    public Collection<V> ensureCollectionFor(K key) {
+        Collection<V> value = get(key);
+        if ( value == null ) {
+            value = factory.get();
+            put(key, value);
+        }
+        return value;
+    }
+    
+    @Override
+    public void add(K key, V element) {
+        ensureCollectionFor(key).add(element);
+    }
+
+
+    @Override
+    public void addAll(K key, Collection<V> elements) {
+        ensureCollectionFor(key).addAll(elements);
+        
+    }
+}

forge-core/src/main/java/forge/util/maps/EnumMapToAmount.java

@@ -0,0 +1,86 @@
+package forge.util.maps;
+
+import java.util.EnumMap;
+import java.util.Map;
+
+
+/** 
+ * TODO: Write javadoc for this type.
+ *
+ */
+public class EnumMapToAmount<T extends Enum<T>> extends EnumMap<T, Integer> implements MapToAmount<T> {
+    private static final long serialVersionUID = -4749796492075359368L;
+
+    public EnumMapToAmount(Class<T> keyType) {
+        super(keyType);
+    }
+
+    public EnumMapToAmount(EnumMap<T, ? extends Integer> m) {
+        super(m);
+    }
+
+    public EnumMapToAmount(Map<T, ? extends Integer> m) {
+        super(m);
+    }
+
+    @Override
+    public void add(T item) {
+        add(item, 1);
+    }
+
+    @Override
+    public void add(T item, int amount) {
+        if (amount <= 0) { return; } // throw an exception maybe?
+        Integer cur = get(item);
+        int newVal = cur == null ? amount : amount + cur.intValue();
+        put(item, Integer.valueOf(newVal));
+    }
+
+    @Override
+    public void addAll(Iterable<T> items) {
+        for (T i : items) {
+            add(i, 1);
+        }
+    }
+
+    @Override
+    public boolean substract(T item) {
+        return substract(item, 1);
+    }
+
+    @Override
+    public boolean substract(T item, int amount) {
+        Integer cur = get(item);
+        if (cur == null) { return false; }
+        int newVal = cur.intValue() - amount;
+        if (newVal > 0) {
+            put(item, Integer.valueOf(newVal));
+        }
+        else {
+            remove(item);
+        }
+        return true;
+    }
+
+    @Override
+    public void substractAll(Iterable<T> items) {
+        for (T i : items) {
+            substract(i);
+        }
+    }
+
+    @Override
+    public int countAll() {
+        int c = 0;
+        for (java.util.Map.Entry<T, Integer> kv : this.entrySet()) {
+            c += kv.getValue().intValue();
+        }
+        return c;
+    }
+
+    @Override
+    public int count(T item) {
+        Integer cur = get(item);
+        return cur == null ? 0 : cur.intValue();
+    }
+}

forge-core/src/main/java/forge/util/maps/HashMapOfLists.java

@@ -0,0 +1,55 @@
+package forge.util.maps;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.base.Supplier;
+
+public class HashMapOfLists<K, V> extends HashMap<K, Collection<V>> implements MapOfLists<K, V> {
+
+    private final Supplier<? extends Collection<V>> factory;
+    public HashMapOfLists(Supplier<? extends Collection<V>> factory) {
+        super();
+        this.factory = factory;
+    }
+
+    public HashMapOfLists(int initialCapacity, float loadFactor, Supplier<? extends Collection<V>> factory) {
+        super(initialCapacity, loadFactor);
+        this.factory = factory;
+    }
+
+    public HashMapOfLists(int initialCapacity, Supplier<? extends Collection<V>> factory) {
+        super(initialCapacity);
+        this.factory = factory;
+    }
+
+    public HashMapOfLists(Map<? extends K, ? extends List<V>> m, Supplier<? extends Collection<V>> factory) {
+        super(m);
+        this.factory = factory;
+    }
+
+    private static final long serialVersionUID = 3029089910183132930L;
+
+    public Collection<V> ensureCollectionFor(K key) {
+        Collection<V> value = get(key);
+        if ( value == null ) {
+            value = factory.get();
+            put(key, value);
+        }
+        return value;
+    }
+    
+    @Override
+    public void add(K key, V element) {
+        ensureCollectionFor(key).add(element);
+    }
+
+
+    @Override
+    public void addAll(K key, Collection<V> elements) {
+        ensureCollectionFor(key).addAll(elements);
+        
+    }
+}

forge-core/src/main/java/forge/util/maps/MapOfLists.java

@@ -0,0 +1,10 @@
+package forge.util.maps;
+
+import java.util.Collection;
+import java.util.Map;
+
+public interface MapOfLists<K, V> extends Map<K, Collection<V>> {
+    void add(K key, V element);
+    void addAll(K key, Collection<V> element);
+    Collection<V> ensureCollectionFor(K key);
+}

forge-core/src/main/java/forge/util/maps/MapToAmount.java

@@ -0,0 +1,18 @@
+package forge.util.maps;
+
+import java.util.Map;
+
+/** 
+ * TODO: Write javadoc for this type.
+ *
+ */
+public interface MapToAmount<K> extends Map<K, Integer> {
+    void add(K item);
+    void add(K item, int amount);
+    void addAll(Iterable<K> items);
+    boolean substract(K item);
+    boolean substract(K item, int amount);
+    void substractAll(Iterable<K> items);
+    int countAll();
+    int count(K item); // just unboxes and returns zero instead of null
+}

forge-core/src/main/java/forge/util/maps/package-info.java

@@ -0,0 +1,3 @@
+/** Utils namespace to hold auxiliary classes for Forge. */
+package forge.util.maps;
+