common/pcc/chemicraft/util/ListHash.java

   1 package pcc.chemicraft.util;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collection;
   5 import java.util.HashMap;
   6 import java.util.Iterator;
   7 import java.util.List;
   8 import java.util.ListIterator;
   9 import java.util.Map;
  10 import java.util.Set;
  11
  12 public class ListHash<K, E>
  13 {
  14    /**
  15     * @author Ponkotate version:1.0.0 dev
  16     *
  17     *         Create ArrayList in HashMap.
  18     */
  19
  20    protected ArrayList<K> keysList = new ArrayList<K>();
  21    protected HashMap<K, ArrayList<E>> elementsHash = new HashMap<K, ArrayList<E>>();
  22
  23    public boolean add(K par1Key, E par2Element)
  24    {
  25       try
  26       {
  27          return this.elementsHash.get(par1Key).add(par2Element);
  28       } catch (Exception e)
  29       {
  30          return this.put(par1Key, par2Element);
  31       }
  32    }
  33
  34    public boolean addAll(K par1Key, Collection<? extends E> par2Collection)
  35    {
  36       return this.elementsHash.get(par1Key).addAll(par2Collection);
  37    }
  38
  39    public boolean addAll(K par1Key, int par2Index, Collection<? extends E> par3Collection)
  40    {
  41       return this.elementsHash.get(par1Key).addAll(par2Index, par3Collection);
  42    }
  43
  44    public void clear()
  45    {
  46       this.elementsHash.clear();
  47    }
  48
  49    public boolean containsKey(K par1Key)
  50    {
  51       return this.elementsHash.containsKey(par1Key);
  52    }
  53
  54    public boolean containsValue(K par1Key)
  55    {
  56       return this.elementsHash.containsValue(par1Key);
  57    }
  58
  59    public boolean contains(K par1Key, E par2Element)
  60    {
  61       return this.elementsHash.get(par1Key).contains(par2Element);
  62    }
  63
  64    public boolean containsAll(K par1Key, Collection<?> par2Collection)
  65    {
  66       return this.elementsHash.get(par1Key).containsAll(par2Collection);
  67    }
  68
  69    public Set<java.util.Map.Entry<K, E>> entrySet()
  70    {
  71       return this.entrySet();
  72    }
  73
  74    public K getKeyList(int par1Index)
  75    {
  76       return this.keysList.get(par1Index);
  77    }
  78
  79    public E get(K par1Key, int par2Index)
  80    {
  81       return this.elementsHash.get(par1Key).get(par2Index);
  82    }
  83
  84    public int indexOf(K par1Key, E par2Element)
  85    {
  86       return this.elementsHash.get(par1Key).indexOf(par2Element);
  87    }
  88
  89    public boolean isKeysListEmpty(K par1Key)
  90    {
  91       return this.elementsHash.get(par1Key).isEmpty();
  92    }
  93
  94    public boolean isElementsHashEmpty()
  95    {
  96       return this.elementsHash.isEmpty();
  97    }
  98
  99    public Iterator<E> iterator(K par1Key)
 100    {
 101       return this.elementsHash.get(par1Key).iterator();
 102    }
 103
 104    public int lastIndexOf(K par1Key, E par2Element)
 105    {
 106       return this.elementsHash.get(par1Key).lastIndexOf(par2Element);
 107    }
 108
 109    public ListIterator<E> listIterator(K par1Key)
 110    {
 111       return this.elementsHash.get(par1Key).listIterator();
 112    }
 113
 114    public ListIterator<E> listIterator(K par1Key, int par2Index)
 115    {
 116       return this.elementsHash.get(par1Key).listIterator(par2Index);
 117    }
 118
 119    public Set<K> keySet()
 120    {
 121       return this.elementsHash.keySet();
 122    }
 123
 124    public boolean put(K par1Key, E par2Element)
 125    {
 126       this.keysList.add(par1Key);
 127
 128       ArrayList<E> elementList = new ArrayList<E>();
 129       this.elementsHash.put(par1Key, elementList);
 130       return this.add(par1Key, par2Element);
 131    }
 132
 133    public void putAll(Map<? extends K, ? extends ArrayList<E>> par1Map)
 134    {
 135       this.elementsHash.putAll(par1Map);
 136    }
 137
 138    public ArrayList<E> remove(K par1Key)
 139    {
 140       return this.elementsHash.remove(par1Key);
 141    }
 142
 143    public boolean remove(K par1Key, E par2Element)
 144    {
 145       return this.elementsHash.get(par1Key).remove(par2Element);
 146    }
 147
 148    public E remove(K par1Key, int par2Index)
 149    {
 150       return this.elementsHash.get(par1Key).remove(par2Index);
 151    }
 152
 153    public boolean removeAll(K par1Key, Collection<?> par2Collection)
 154    {
 155       return this.elementsHash.get(par1Key).removeAll(par2Collection);
 156    }
 157
 158    public boolean retainAll(K par1Key, Collection<?> par2Collection)
 159    {
 160       return this.elementsHash.get(par1Key).retainAll(par2Collection);
 161    }
 162
 163    public E set(K par1Key, int par2Index, E par3Element)
 164    {
 165       return this.elementsHash.get(par1Key).set(par2Index, par3Element);
 166    }
 167
 168    public int sizeElementsHash()
 169    {
 170       return this.elementsHash.size();
 171    }
 172
 173    public int sizeKeysList()
 174    {
 175       return this.keysList.size();
 176    }
 177
 178    public int sizeElementsList(K par1Key)
 179    {
 180       return this.elementsHash.get(par1Key).size();
 181    }
 182
 183    public List<E> subList(K par1Key, int par2FromIndex, int par3ToIndex)
 184    {
 185       return this.elementsHash.get(par1Key).subList(par2FromIndex, par3ToIndex);
 186    }
 187
 188    public E[] toArray(K par1Key)
 189    {
 190       return (E[])this.elementsHash.get(par1Key).toArray();
 191    }
 192
 193    public <T> T[] toArray(K par1Key, T[] par2Array)
 194    {
 195       return this.elementsHash.get(par1Key).toArray(par2Array);
 196    }
 197
 198    public Collection<ArrayList<E>> values()
 199    {
 200       return this.elementsHash.values();
 201    }
 202
 203 }