1 package sharin.unlinq;
2
3 import java.util.Collection;
4 import java.util.Comparator;
5 import java.util.Iterator;
6 import java.util.LinkedHashMap;
7 import java.util.List;
8 import java.util.Map;
9 import java.util.Set;
10
11 public class BasicDictionary<TKey, TValue> implements Dictionary<TKey, TValue> {
12
13 private Map<TKey, TValue> map;
14
15 public BasicDictionary() {
16 this(null);
17 }
18
19 public BasicDictionary(Map<TKey, TValue> map) {
20
21 if (map == null) {
22 map = new LinkedHashMap<TKey, TValue>();
23 }
24
25 this.map = map;
26 }
27
28 private Enumerable<Entry<TKey, TValue>> getEnumerable() {
29 return new BasicEnumerable<Entry<TKey, TValue>>(map.entrySet());
30 }
31
32 @Override
33 public String toString() {
34 return map.toString();
35 }
36
37 public void clear() {
38 map.clear();
39 }
40
41 public boolean containsKey(Object key) {
42 return map.containsKey(key);
43 }
44
45 public boolean containsValue(Object value) {
46 return map.containsValue(value);
47 }
48
49 public Set<Entry<TKey, TValue>> entrySet() {
50 return map.entrySet();
51 }
52
53 public TValue get(Object key) {
54 return map.get(key);
55 }
56
57 public boolean isEmpty() {
58 return map.isEmpty();
59 }
60
61 public Set<TKey> keySet() {
62 return map.keySet();
63 }
64
65 public TValue put(TKey key, TValue value) {
66 return map.put(key, value);
67 }
68
69 public void putAll(Map<? extends TKey, ? extends TValue> t) {
70 map.putAll(t);
71 }
72
73 public TValue remove(Object key) {
74 return map.remove(key);
75 }
76
77 public int size() {
78 return map.size();
79 }
80
81 public Collection<TValue> values() {
82 return map.values();
83 }
84
85 public <A, R> R aggregate(A seed, Func2<A, Entry<TKey, TValue>, A> func,
86 Func<A, R> resultSelector) {
87 return getEnumerable().aggregate(seed, func, resultSelector);
88 }
89
90 public <A> A aggregate(A seed, Func2<A, Entry<TKey, TValue>, A> func) {
91 return getEnumerable().aggregate(seed, func);
92 }
93
94 public Entry<TKey, TValue> aggregate(
95 Func2<Entry<TKey, TValue>, Entry<TKey, TValue>, Entry<TKey, TValue>> func) {
96 return getEnumerable().aggregate(func);
97 }
98
99 public Boolean all(Func<Entry<TKey, TValue>, Boolean> predicate) {
100 return getEnumerable().all(predicate);
101 }
102
103 public Boolean any() {
104 return getEnumerable().any();
105 }
106
107 public Boolean any(Func<Entry<TKey, TValue>, Boolean> predicate) {
108 return getEnumerable().any(predicate);
109 }
110
111 public double average() {
112 return getEnumerable().average();
113 }
114
115 public double average(Func<Entry<TKey, TValue>, Integer> selector) {
116 return getEnumerable().average(selector);
117 }
118
119 public double averageDouble() {
120 return getEnumerable().averageDouble();
121 }
122
123 public double averageDouble(Func<Entry<TKey, TValue>, Double> selector) {
124 return getEnumerable().averageDouble(selector);
125 }
126
127 public float averageFloat() {
128 return getEnumerable().averageFloat();
129 }
130
131 public float averageFloat(Func<Entry<TKey, TValue>, Float> selector) {
132 return getEnumerable().averageFloat(selector);
133 }
134
135 public double averageLong() {
136 return getEnumerable().averageLong();
137 }
138
139 public double averageLong(Func<Entry<TKey, TValue>, Long> selector) {
140 return getEnumerable().averageLong(selector);
141 }
142
143 public <R> Enumerable<R> cast(Class<R> resultClass) {
144 return getEnumerable().cast(resultClass);
145 }
146
147 public Enumerable<Entry<TKey, TValue>> concat(
148 Enumerable<Entry<TKey, TValue>> second) {
149 return getEnumerable().concat(second);
150 }
151
152 public boolean contains(Object o) {
153 return getEnumerable().contains(o);
154 }
155
156 public int count() {
157 return getEnumerable().count();
158 }
159
160 public int count(Func<Entry<TKey, TValue>, Boolean> predicate) {
161 return getEnumerable().count(predicate);
162 }
163
164 public Enumerable<Entry<TKey, TValue>> defaultIfEmpty() {
165 return getEnumerable().defaultIfEmpty();
166 }
167
168 public Enumerable<Entry<TKey, TValue>> defaultIfEmpty(
169 Entry<TKey, TValue> defaultValue) {
170 return getEnumerable().defaultIfEmpty(defaultValue);
171 }
172
173 public Enumerable<Entry<TKey, TValue>> distinct() {
174 return getEnumerable().distinct();
175 }
176
177 public Entry<TKey, TValue> elementAt(int index) {
178 return getEnumerable().elementAt(index);
179 }
180
181 public Entry<TKey, TValue> elementAtOrDefault(int index,
182 Entry<TKey, TValue> defaultValue) {
183 return getEnumerable().elementAtOrDefault(index, defaultValue);
184 }
185
186 public Entry<TKey, TValue> elementAtOrDefault(int index) {
187 return getEnumerable().elementAtOrDefault(index);
188 }
189
190 public Enumerable<Entry<TKey, TValue>> except(
191 Enumerable<Entry<TKey, TValue>> second) {
192 return getEnumerable().except(second);
193 }
194
195 public Entry<TKey, TValue> first() {
196 return getEnumerable().first();
197 }
198
199 public Entry<TKey, TValue> first(
200 Func<Entry<TKey, TValue>, Boolean> predicate) {
201 return getEnumerable().first(predicate);
202 }
203
204 public Entry<TKey, TValue> firstOrDefault() {
205 return getEnumerable().firstOrDefault();
206 }
207
208 public Entry<TKey, TValue> firstOrDefault(Entry<TKey, TValue> defaultValue) {
209 return getEnumerable().firstOrDefault(defaultValue);
210 }
211
212 public Entry<TKey, TValue> firstOrDefault(
213 Func<Entry<TKey, TValue>, Boolean> predicate,
214 Entry<TKey, TValue> defaultValue) {
215 return getEnumerable().firstOrDefault(predicate, defaultValue);
216 }
217
218 public Entry<TKey, TValue> firstOrDefault(
219 Func<Entry<TKey, TValue>, Boolean> predicate) {
220 return getEnumerable().firstOrDefault(predicate);
221 }
222
223 public <K, E, R> Enumerable<R> groupBy(
224 Func<Entry<TKey, TValue>, K> keySelector,
225 Func<Entry<TKey, TValue>, E> elementSelector,
226 Func2<K, Enumerable<E>, R> resultSelector) {
227 return getEnumerable().groupBy(keySelector, elementSelector,
228 resultSelector);
229 }
230
231 public <K, E> Enumerable<Grouping<K, E>> groupBy(
232 Func<Entry<TKey, TValue>, K> keySelector,
233 Func<Entry<TKey, TValue>, E> elementSelector) {
234 return getEnumerable().groupBy(keySelector, elementSelector);
235 }
236
237 public <K, R> Enumerable<R> groupBy(
238 Func<Entry<TKey, TValue>, K> keySelector,
239 Func2<K, Enumerable<Entry<TKey, TValue>>, R> resultSelector) {
240 return getEnumerable().groupBy(keySelector, resultSelector);
241 }
242
243 public <K> Enumerable<Grouping<K, Entry<TKey, TValue>>> groupBy(
244 Func<Entry<TKey, TValue>, K> keySelector) {
245 return getEnumerable().groupBy(keySelector);
246 }
247
248 public <I, K, R> Enumerable<R> groupJoin(Enumerable<I> inner,
249 Func<Entry<TKey, TValue>, K> outerKeySelector,
250 Func<I, K> innerKeySelector,
251 Func2<Entry<TKey, TValue>, Enumerable<I>, R> resultSelector) {
252 return getEnumerable().groupJoin(inner, outerKeySelector,
253 innerKeySelector, resultSelector);
254 }
255
256 public Enumerable<Entry<TKey, TValue>> intersect(
257 Enumerable<Entry<TKey, TValue>> second) {
258 return getEnumerable().intersect(second);
259 }
260
261 public Iterator<Entry<TKey, TValue>> iterator() {
262 return getEnumerable().iterator();
263 }
264
265 public <I, K, R> Enumerable<R> join(Enumerable<I> inner,
266 Func<Entry<TKey, TValue>, K> outerKeySelector,
267 Func<I, K> innerKeySelector,
268 Func2<Entry<TKey, TValue>, I, R> resultSelector) {
269 return getEnumerable().join(inner, outerKeySelector, innerKeySelector,
270 resultSelector);
271 }
272
273 public Entry<TKey, TValue> last() {
274 return getEnumerable().last();
275 }
276
277 public Entry<TKey, TValue> last(Func<Entry<TKey, TValue>, Boolean> predicate) {
278 return getEnumerable().last(predicate);
279 }
280
281 public Entry<TKey, TValue> lastOrDefault() {
282 return getEnumerable().lastOrDefault();
283 }
284
285 public Entry<TKey, TValue> lastOrDefault(Entry<TKey, TValue> defaultValue) {
286 return getEnumerable().lastOrDefault(defaultValue);
287 }
288
289 public Entry<TKey, TValue> lastOrDefault(
290 Func<Entry<TKey, TValue>, Boolean> predicate,
291 Entry<TKey, TValue> defaultValue) {
292 return getEnumerable().lastOrDefault(predicate, defaultValue);
293 }
294
295 public Entry<TKey, TValue> lastOrDefault(
296 Func<Entry<TKey, TValue>, Boolean> predicate) {
297 return getEnumerable().lastOrDefault(predicate);
298 }
299
300 public long longCount() {
301 return getEnumerable().longCount();
302 }
303
304 public long longCount(Func<Entry<TKey, TValue>, Boolean> predicate) {
305 return getEnumerable().longCount(predicate);
306 }
307
308 public Entry<TKey, TValue> max() {
309 return getEnumerable().max();
310 }
311
312 public <R extends Comparable<R>> R max(Func<Entry<TKey, TValue>, R> selector) {
313 return getEnumerable().max(selector);
314 }
315
316 public Entry<TKey, TValue> min() {
317 return getEnumerable().min();
318 }
319
320 public <R extends Comparable<R>> R min(Func<Entry<TKey, TValue>, R> selector) {
321 return getEnumerable().min(selector);
322 }
323
324 public <R> Enumerable<R> ofType(Class<R> resultClass) {
325 return getEnumerable().ofType(resultClass);
326 }
327
328 public <K> OrderedEnumerable<Entry<TKey, TValue>> orderBy(
329 Func<Entry<TKey, TValue>, K> keySelector, Comparator<K> comparator) {
330 return getEnumerable().orderBy(keySelector, comparator);
331 }
332
333 public <K> OrderedEnumerable<Entry<TKey, TValue>> orderBy(
334 Func<Entry<TKey, TValue>, K> keySelector) {
335 return getEnumerable().orderBy(keySelector);
336 }
337
338 public <K> OrderedEnumerable<Entry<TKey, TValue>> orderByDescending(
339 Func<Entry<TKey, TValue>, K> keySelector, Comparator<K> comparator) {
340 return getEnumerable().orderByDescending(keySelector, comparator);
341 }
342
343 public <K> OrderedEnumerable<Entry<TKey, TValue>> orderByDescending(
344 Func<Entry<TKey, TValue>, K> keySelector) {
345 return getEnumerable().orderByDescending(keySelector);
346 }
347
348 public Enumerable<Entry<TKey, TValue>> reverse() {
349 return getEnumerable().reverse();
350 }
351
352 public <R> Enumerable<R> select(Func<Entry<TKey, TValue>, R> selector) {
353 return getEnumerable().select(selector);
354 }
355
356 public <R> Enumerable<R> select(
357 Func2<Entry<TKey, TValue>, Integer, R> selector) {
358 return getEnumerable().select(selector);
359 }
360
361 public <C, R> Enumerable<R> selectMany(
362 Func<Entry<TKey, TValue>, Enumerable<C>> collectionSelector,
363 Func2<Entry<TKey, TValue>, C, R> resultSelector) {
364 return getEnumerable().selectMany(collectionSelector, resultSelector);
365 }
366
367 public <R> Enumerable<R> selectMany(
368 Func<Entry<TKey, TValue>, Enumerable<R>> selector) {
369 return getEnumerable().selectMany(selector);
370 }
371
372 public <C, R> Enumerable<R> selectMany(
373 Func2<Entry<TKey, TValue>, Integer, Enumerable<C>> collectionSelector,
374 Func2<Entry<TKey, TValue>, C, R> resultSelector) {
375 return getEnumerable().selectMany(collectionSelector, resultSelector);
376 }
377
378 public <R> Enumerable<R> selectMany(
379 Func2<Entry<TKey, TValue>, Integer, Enumerable<R>> selector) {
380 return getEnumerable().selectMany(selector);
381 }
382
383 public Boolean sequenceEqual(Enumerable<Entry<TKey, TValue>> second) {
384 return getEnumerable().sequenceEqual(second);
385 }
386
387 public Entry<TKey, TValue> single() {
388 return getEnumerable().single();
389 }
390
391 public Entry<TKey, TValue> single(
392 Func<Entry<TKey, TValue>, Boolean> predicate) {
393 return getEnumerable().single(predicate);
394 }
395
396 public Entry<TKey, TValue> singleOrDefault() {
397 return getEnumerable().singleOrDefault();
398 }
399
400 public Entry<TKey, TValue> singleOrDefault(Entry<TKey, TValue> defaultValue) {
401 return getEnumerable().singleOrDefault(defaultValue);
402 }
403
404 public Entry<TKey, TValue> singleOrDefault(
405 Func<Entry<TKey, TValue>, Boolean> predicate,
406 Entry<TKey, TValue> defaultValue) {
407 return getEnumerable().singleOrDefault(predicate, defaultValue);
408 }
409
410 public Entry<TKey, TValue> singleOrDefault(
411 Func<Entry<TKey, TValue>, Boolean> predicate) {
412 return getEnumerable().singleOrDefault(predicate);
413 }
414
415 public Enumerable<Entry<TKey, TValue>> skip(int count) {
416 return getEnumerable().skip(count);
417 }
418
419 public Enumerable<Entry<TKey, TValue>> skipWhile(
420 Func<Entry<TKey, TValue>, Boolean> predicate) {
421 return getEnumerable().skipWhile(predicate);
422 }
423
424 public Enumerable<Entry<TKey, TValue>> skipWhile(
425 Func2<Entry<TKey, TValue>, Integer, Boolean> predicate) {
426 return getEnumerable().skipWhile(predicate);
427 }
428
429 public int sum() {
430 return getEnumerable().sum();
431 }
432
433 public int sum(Func<Entry<TKey, TValue>, Integer> selector) {
434 return getEnumerable().sum(selector);
435 }
436
437 public double sumDouble() {
438 return getEnumerable().sumDouble();
439 }
440
441 public double sumDouble(Func<Entry<TKey, TValue>, Double> selector) {
442 return getEnumerable().sumDouble(selector);
443 }
444
445 public float sumFloat() {
446 return getEnumerable().sumFloat();
447 }
448
449 public float sumFloat(Func<Entry<TKey, TValue>, Float> selector) {
450 return getEnumerable().sumFloat(selector);
451 }
452
453 public long sumLong() {
454 return getEnumerable().sumLong();
455 }
456
457 public long sumLong(Func<Entry<TKey, TValue>, Long> selector) {
458 return getEnumerable().sumLong(selector);
459 }
460
461 public Enumerable<Entry<TKey, TValue>> take(int count) {
462 return getEnumerable().take(count);
463 }
464
465 public Enumerable<Entry<TKey, TValue>> takeWhile(
466 Func<Entry<TKey, TValue>, Boolean> predicate) {
467 return getEnumerable().takeWhile(predicate);
468 }
469
470 public Enumerable<Entry<TKey, TValue>> takeWhile(
471 Func2<Entry<TKey, TValue>, Integer, Boolean> predicate) {
472 return getEnumerable().takeWhile(predicate);
473 }
474
475 public Object[] toArray() {
476 return getEnumerable().toArray();
477 }
478
479 public <R> R[] toArray(Class<R> resultClass) {
480 return getEnumerable().toArray(resultClass);
481 }
482
483 public <K, E> Dictionary<K, E> toDictionary(
484 Func<Entry<TKey, TValue>, K> keySelector,
485 Func<Entry<TKey, TValue>, E> elementSelector) {
486 return getEnumerable().toDictionary(keySelector, elementSelector);
487 }
488
489 public <K> Dictionary<K, Entry<TKey, TValue>> toDictionary(
490 Func<Entry<TKey, TValue>, K> keySelector) {
491 return getEnumerable().toDictionary(keySelector);
492 }
493
494 public EnumerableList<Entry<TKey, TValue>> toEnumerableList() {
495 return getEnumerable().toEnumerableList();
496 }
497
498 public List<Entry<TKey, TValue>> toList() {
499 return getEnumerable().toList();
500 }
501
502 public <K, E> Map<K, List<E>> toListMap(
503 Func<Entry<TKey, TValue>, K> keySelector,
504 Func<Entry<TKey, TValue>, E> elementSelector) {
505 return getEnumerable().toListMap(keySelector, elementSelector);
506 }
507
508 public <K> Map<K, List<Entry<TKey, TValue>>> toListMap(
509 Func<Entry<TKey, TValue>, K> keySelector) {
510 return getEnumerable().toListMap(keySelector);
511 }
512
513 public <K, E> Lookup<K, E> toLookup(
514 Func<Entry<TKey, TValue>, K> keySelector,
515 Func<Entry<TKey, TValue>, E> elementSelector) {
516 return getEnumerable().toLookup(keySelector, elementSelector);
517 }
518
519 public <K> Lookup<K, Entry<TKey, TValue>> toLookup(
520 Func<Entry<TKey, TValue>, K> keySelector) {
521 return getEnumerable().toLookup(keySelector);
522 }
523
524 public <K, E> Map<K, E> toMap(Func<Entry<TKey, TValue>, K> keySelector,
525 Func<Entry<TKey, TValue>, E> elementSelector) {
526 return getEnumerable().toMap(keySelector, elementSelector);
527 }
528
529 public <K> Map<K, Entry<TKey, TValue>> toMap(
530 Func<Entry<TKey, TValue>, K> keySelector) {
531 return getEnumerable().toMap(keySelector);
532 }
533
534 public Enumerable<Entry<TKey, TValue>> union(
535 Enumerable<Entry<TKey, TValue>> second) {
536 return getEnumerable().union(second);
537 }
538
539 public Enumerable<Entry<TKey, TValue>> where(
540 Func<Entry<TKey, TValue>, Boolean> predicate) {
541 return getEnumerable().where(predicate);
542 }
543
544 public Enumerable<Entry<TKey, TValue>> where(
545 Func2<Entry<TKey, TValue>, Integer, Boolean> predicate) {
546 return getEnumerable().where(predicate);
547 }
548 }