View Javadoc

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 }