View Javadoc

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