OSDN Git Service

いろいろした
[chemicraft/chemicraft.git] / 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 }