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