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 }