1 package sharin.unlinq; 2 3 import java.lang.reflect.Array; 4 import java.util.ArrayList; 5 import java.util.Arrays; 6 import java.util.Collections; 7 import java.util.Comparator; 8 import java.util.HashMap; 9 import java.util.HashSet; 10 import java.util.Iterator; 11 import java.util.LinkedHashMap; 12 import java.util.List; 13 import java.util.Map; 14 import java.util.NoSuchElementException; 15 import java.util.Queue; 16 import java.util.Set; 17 import java.util.Map.Entry; 18 19 import sharin.util.ArrayUtils; 20 21 public class BasicEnumerable<T> implements Enumerable<T> { 22 23 private final Iterable<T> iterable; 24 25 public BasicEnumerable(Iterable<T> iterable) { 26 27 if (iterable == null) { 28 iterable = Collections.<T> emptyList(); 29 } 30 31 this.iterable = iterable; 32 } 33 34 public Iterator<T> iterator() { 35 return iterable.iterator(); 36 } 37 38 public static <E> Enumerable<E> from(Iterable<E> iterable) { 39 return new BasicEnumerable<E>(iterable); 40 } 41 42 public static <E> Enumerable<E> from(E... objects) { 43 44 if (objects == null) { 45 return new BasicEnumerable<E>(null); 46 } 47 48 return new BasicEnumerable<E>(Arrays.asList(objects)); 49 } 50 51 public static Enumerable<Boolean> fromBoolean(boolean... values) { 52 return new BasicEnumerable<Boolean>(Arrays.asList(ArrayUtils 53 .toWrappers(values))); 54 } 55 56 public static Enumerable<Byte> fromByte(byte... values) { 57 return new BasicEnumerable<Byte>(Arrays.asList(ArrayUtils 58 .toWrappers(values))); 59 } 60 61 public static Enumerable<Character> fromChar(char... values) { 62 return new BasicEnumerable<Character>(Arrays.asList(ArrayUtils 63 .toWrappers(values))); 64 } 65 66 public static Enumerable<Short> fromShort(short... values) { 67 return new BasicEnumerable<Short>(Arrays.asList(ArrayUtils 68 .toWrappers(values))); 69 } 70 71 public static Enumerable<Integer> from(int... values) { 72 return new BasicEnumerable<Integer>(Arrays.asList(ArrayUtils 73 .toWrappers(values))); 74 } 75 76 public static Enumerable<Long> fromLong(long... values) { 77 return new BasicEnumerable<Long>(Arrays.asList(ArrayUtils 78 .toWrappers(values))); 79 } 80 81 public static Enumerable<Float> fromFloat(float... values) { 82 return new BasicEnumerable<Float>(Arrays.asList(ArrayUtils 83 .toWrappers(values))); 84 } 85 86 public static Enumerable<Double> fromDouble(double... values) { 87 return new BasicEnumerable<Double>(Arrays.asList(ArrayUtils 88 .toWrappers(values))); 89 } 90 91 public T aggregate(Func2<T, T, T> func) { 92 Iterator<T> iterator = iterable.iterator(); 93 T seed = iterator.next(); 94 return doAggregate(seed, func, iterator); 95 } 96 97 public <A> A aggregate(A seed, Func2<A, T, A> func) { 98 return doAggregate(seed, func, iterable.iterator()); 99 } 100 101 public <A, R> R aggregate(A seed, Func2<A, T, A> func, 102 Func<A, R> resultSelector) { 103 104 A a = doAggregate(seed, func, iterable.iterator()); 105 return resultSelector.call(a); 106 } 107 108 private <A> A doAggregate(A seed, Func2<A, T, A> func, Iterator<T> iterator) { 109 A a = seed; 110 111 while (iterator.hasNext()) { 112 a = func.call(a, iterator.next()); 113 } 114 115 return a; 116 } 117 118 public Boolean all(Func<T, Boolean> predicate) { 119 120 for (T t : iterable) { 121 122 if (!predicate.call(t)) { 123 return false; 124 } 125 } 126 127 return true; 128 } 129 130 public Boolean any() { 131 return iterable.iterator().hasNext(); 132 } 133 134 public Boolean any(Func<T, Boolean> predicate) { 135 136 for (T t : iterable) { 137 138 if (predicate.call(t)) { 139 return true; 140 } 141 } 142 143 return false; 144 } 145 146 public double average() { 147 Iterator<T> iterator = iterable.iterator(); 148 double sum = (Integer) iterator.next(); 149 int count = 1; 150 151 while (iterator.hasNext()) { 152 sum += (Integer) iterator.next(); 153 count++; 154 } 155 156 return sum / count; 157 } 158 159 public double averageLong() { 160 Iterator<T> iterator = iterable.iterator(); 161 double sum = (Long) iterator.next(); 162 int count = 1; 163 164 while (iterator.hasNext()) { 165 sum += (Long) iterator.next(); 166 count++; 167 } 168 169 return sum / count; 170 } 171 172 public float averageFloat() { 173 Iterator<T> iterator = iterable.iterator(); 174 float sum = (Float) iterator.next(); 175 int count = 1; 176 177 while (iterator.hasNext()) { 178 sum += (Float) iterator.next(); 179 count++; 180 } 181 182 return sum / count; 183 } 184 185 public double averageDouble() { 186 Iterator<T> iterator = iterable.iterator(); 187 double sum = (Double) iterator.next(); 188 int count = 1; 189 190 while (iterator.hasNext()) { 191 sum += (Double) iterator.next(); 192 count++; 193 } 194 195 return sum / count; 196 } 197 198 public double average(Func<T, Integer> selector) { 199 Iterator<T> iterator = iterable.iterator(); 200 double sum = selector.call(iterator.next()); 201 int count = 1; 202 203 while (iterator.hasNext()) { 204 sum += selector.call(iterator.next()); 205 count++; 206 } 207 208 return sum / count; 209 } 210 211 public double averageLong(Func<T, Long> selector) { 212 Iterator<T> iterator = iterable.iterator(); 213 double sum = selector.call(iterator.next()); 214 int count = 1; 215 216 while (iterator.hasNext()) { 217 sum += selector.call(iterator.next()); 218 count++; 219 } 220 221 return sum / count; 222 } 223 224 public float averageFloat(Func<T, Float> selector) { 225 Iterator<T> iterator = iterable.iterator(); 226 float sum = selector.call(iterator.next()); 227 int count = 1; 228 229 while (iterator.hasNext()) { 230 sum += selector.call(iterator.next()); 231 count++; 232 } 233 234 return sum / count; 235 } 236 237 public double averageDouble(Func<T, Double> selector) { 238 Iterator<T> iterator = iterable.iterator(); 239 double sum = selector.call(iterator.next()); 240 int count = 1; 241 242 while (iterator.hasNext()) { 243 sum += selector.call(iterator.next()); 244 count++; 245 } 246 247 return sum / count; 248 } 249 250 public <R> Enumerable<R> cast(final Class<R> resultClass) { 251 return new BasicEnumerable<R>(new Iterable<R>() { 252 253 public Iterator<R> iterator() { 254 return new Iterator<R>() { 255 256 private final Iterator<T> iterator = iterable.iterator(); 257 258 public boolean hasNext() { 259 return iterator.hasNext(); 260 } 261 262 public R next() { 263 return resultClass.cast(iterator.next()); 264 } 265 266 public void remove() { 267 throw new UnsupportedOperationException(); 268 } 269 }; 270 } 271 }); 272 } 273 274 public Enumerable<T> concat(final Enumerable<T> second) { 275 return new BasicEnumerable<T>(new Iterable<T>() { 276 277 public Iterator<T> iterator() { 278 return new QueuedIterator<T, T, T>(new ConcatenatedIterator<T>( 279 iterable.iterator(), second.iterator())) { 280 281 @Override 282 protected void addElement(Queue<T> queue, T t) { 283 queue.add(t); 284 } 285 286 @Override 287 protected T toResult(T e) { 288 return e; 289 } 290 }; 291 } 292 }); 293 } 294 295 public boolean contains(Object o) { 296 297 for (T t : iterable) { 298 299 if (equals(o, t)) { 300 return true; 301 } 302 } 303 304 return false; 305 } 306 307 private boolean equals(Object o1, Object o2) { 308 309 if (o2 == null) { 310 311 if (o1 == null) { 312 return true; 313 } 314 315 } else { 316 317 if (o2.equals(o1)) { 318 return true; 319 } 320 } 321 322 return false; 323 } 324 325 public int count() { 326 int c = 0; 327 328 for (Iterator<T> it = iterable.iterator(); it.hasNext(); it.next()) { 329 c++; 330 } 331 332 return c; 333 } 334 335 public int count(Func<T, Boolean> predicate) { 336 int c = 0; 337 338 for (T t : iterable) { 339 340 if (predicate.call(t)) { 341 c++; 342 } 343 } 344 345 return c; 346 } 347 348 public Enumerable<T> defaultIfEmpty() { 349 return defaultIfEmpty(null); 350 } 351 352 public Enumerable<T> defaultIfEmpty(T defaultValue) { 353 354 if (iterable.iterator().hasNext()) { 355 return new BasicEnumerable<T>(iterable); 356 } 357 358 List<T> list = new ArrayList<T>(); 359 list.add(defaultValue); 360 return new BasicEnumerable<T>(list); 361 } 362 363 public Enumerable<T> distinct() { 364 return new BasicEnumerable<T>(new Iterable<T>() { 365 366 public Iterator<T> iterator() { 367 return new QueuedIterator<T, T, T>(iterable.iterator()) { 368 369 private final Set<T> set = new HashSet<T>(); 370 371 @Override 372 protected void addElement(Queue<T> queue, T t) { 373 374 if (!set.contains(t)) { 375 queue.add(t); 376 set.add(t); 377 } 378 } 379 380 @Override 381 protected T toResult(T e) { 382 return e; 383 } 384 }; 385 } 386 }); 387 } 388 389 public T elementAt(int index) { 390 Iterator<T> iterator = iterable.iterator(); 391 392 for (int i = 0; i < index; i++) { 393 iterator.next(); 394 } 395 396 return iterator.next(); 397 } 398 399 public T elementAtOrDefault(int index) { 400 return elementAtOrDefault(index, null); 401 } 402 403 public T elementAtOrDefault(int index, T defaultValue) { 404 Iterator<T> iterator = iterable.iterator(); 405 406 for (int i = 0; i < index; i++) { 407 408 if (!iterator.hasNext()) { 409 return defaultValue; 410 } 411 412 iterator.next(); 413 } 414 415 if (!iterator.hasNext()) { 416 return defaultValue; 417 } 418 419 return iterator.next(); 420 } 421 422 public static <R> Enumerable<R> empty() { 423 return new BasicEnumerable<R>((Iterable<R>) null); 424 } 425 426 public Enumerable<T> except(final Enumerable<T> second) { 427 return new BasicEnumerable<T>(new Iterable<T>() { 428 429 public Iterator<T> iterator() { 430 return new QueuedIterator<T, T, T>(iterable.iterator()) { 431 432 private final Set<T> firstSet = new HashSet<T>(); 433 434 private final Set<T> secondSet = new HashSet<T>(second 435 .toList()); 436 437 @Override 438 protected void addElement(Queue<T> queue, T t) { 439 440 if (!secondSet.contains(t) && !firstSet.contains(t)) { 441 queue.add(t); 442 firstSet.add(t); 443 } 444 } 445 446 @Override 447 protected T toResult(T e) { 448 return e; 449 } 450 }; 451 } 452 }); 453 } 454 455 public T first() { 456 return iterable.iterator().next(); 457 } 458 459 public T first(Func<T, Boolean> predicate) { 460 461 for (T t : iterable) { 462 463 if (predicate.call(t)) { 464 return t; 465 } 466 } 467 468 throw new NoSuchElementException(); 469 } 470 471 public T firstOrDefault() { 472 return firstOrDefault((T) null); 473 } 474 475 public T firstOrDefault(T defaultValue) { 476 Iterator<T> iterator = iterable.iterator(); 477 478 if (!iterator.hasNext()) { 479 return defaultValue; 480 } 481 482 return iterator.next(); 483 } 484 485 public T firstOrDefault(Func<T, Boolean> predicate) { 486 return firstOrDefault(predicate, null); 487 } 488 489 public T firstOrDefault(Func<T, Boolean> predicate, T defaultValue) { 490 491 for (T t : iterable) { 492 493 if (predicate.call(t)) { 494 return t; 495 } 496 } 497 498 return defaultValue; 499 } 500 501 public <K> Enumerable<Grouping<K, T>> groupBy(Func<T, K> keySelector) { 502 return groupBy(keySelector, getPassThroughFunc()); 503 } 504 505 public <K, R> Enumerable<R> groupBy(Func<T, K> keySelector, 506 Func2<K, Enumerable<T>, R> resultSelector) { 507 508 return groupBy(keySelector, getPassThroughFunc(), resultSelector); 509 } 510 511 public <K, E> Enumerable<Grouping<K, E>> groupBy(Func<T, K> keySelector, 512 Func<T, E> elementSelector) { 513 514 LinkedHashMap<K, List<E>> map = doGroupBy(keySelector, elementSelector); 515 List<Grouping<K, E>> groupList = new ArrayList<Grouping<K, E>>(); 516 517 for (Entry<K, List<E>> entry : map.entrySet()) { 518 groupList.add(new BasicGrouping<K, E>(entry.getKey(), 519 new BasicEnumerable<E>(entry.getValue()))); 520 } 521 522 return new BasicEnumerable<Grouping<K, E>>(groupList); 523 } 524 525 public <K, E, R> Enumerable<R> groupBy(Func<T, K> keySelector, 526 Func<T, E> elementSelector, 527 Func2<K, Enumerable<E>, R> resultSelector) { 528 529 LinkedHashMap<K, List<E>> map = doGroupBy(keySelector, elementSelector); 530 List<R> resultList = new ArrayList<R>(); 531 532 for (Entry<K, List<E>> entry : map.entrySet()) { 533 resultList.add(resultSelector.call(entry.getKey(), 534 new BasicEnumerable<E>(entry.getValue()))); 535 } 536 537 return new BasicEnumerable<R>(resultList); 538 } 539 540 private <E, K> LinkedHashMap<K, List<E>> doGroupBy(Func<T, K> keySelector, 541 Func<T, E> elementSelector) { 542 543 LinkedHashMap<K, List<E>> map = new LinkedHashMap<K, List<E>>(); 544 545 for (T entity : iterable) { 546 K key = keySelector.call(entity); 547 List<E> list = map.get(key); 548 549 if (list == null) { 550 list = new ArrayList<E>(); 551 map.put(key, list); 552 } 553 554 list.add(elementSelector.call(entity)); 555 } 556 557 return map; 558 } 559 560 public <I, K, R> Enumerable<R> groupJoin(final Enumerable<I> inner, 561 final Func<T, K> outerKeySelector, 562 final Func<I, K> innerKeySelector, 563 final Func2<T, Enumerable<I>, R> resultSelector) { 564 565 return new BasicEnumerable<R>(new Iterable<R>() { 566 567 public Iterator<R> iterator() { 568 569 return new Iterator<R>() { 570 571 private final Iterator<T> iterator = iterable.iterator(); 572 573 private final Map<K, List<I>> innerListMap; 574 575 { 576 innerListMap = new HashMap<K, List<I>>(); 577 578 for (I innerEntity : inner) { 579 K innerKey = innerKeySelector.call(innerEntity); 580 List<I> innerList = innerListMap.get(innerKey); 581 582 if (innerList == null) { 583 innerList = new ArrayList<I>(); 584 innerListMap.put(innerKey, innerList); 585 } 586 587 innerList.add(innerEntity); 588 } 589 } 590 591 public boolean hasNext() { 592 return iterator.hasNext(); 593 } 594 595 public R next() { 596 T outerEntity = iterator.next(); 597 K outerKey = outerKeySelector.call(outerEntity); 598 List<I> innerList = innerListMap.get(outerKey); 599 return resultSelector.call(outerEntity, 600 new BasicEnumerable<I>(innerList)); 601 } 602 603 public void remove() { 604 throw new UnsupportedOperationException(); 605 } 606 }; 607 } 608 }); 609 } 610 611 public Enumerable<T> intersect(final Enumerable<T> second) { 612 return new BasicEnumerable<T>(new Iterable<T>() { 613 614 public Iterator<T> iterator() { 615 return new QueuedIterator<T, T, T>(iterable.iterator()) { 616 617 private final Set<T> firstSet = new HashSet<T>(); 618 619 private final Set<T> secondSet = new HashSet<T>(second 620 .toList()); 621 622 @Override 623 protected void addElement(Queue<T> queue, T t) { 624 625 if (secondSet.contains(t) && !firstSet.contains(t)) { 626 queue.add(t); 627 firstSet.add(t); 628 } 629 } 630 631 @Override 632 protected T toResult(T e) { 633 return e; 634 } 635 }; 636 } 637 }); 638 } 639 640 public <I, K, R> Enumerable<R> join(final Enumerable<I> inner, 641 final Func<T, K> outerKeySelector, 642 final Func<I, K> innerKeySelector, 643 final Func2<T, I, R> resultSelector) { 644 645 return new BasicEnumerable<R>(new Iterable<R>() { 646 647 public Iterator<R> iterator() { 648 return new QueuedIterator<T, Pair<T, I>, R>(iterable.iterator()) { 649 650 private final Map<K, I> innerMap; 651 652 { 653 innerMap = new HashMap<K, I>(); 654 655 for (I innerEntity : inner) { 656 K innerKey = innerKeySelector.call(innerEntity); 657 innerMap.put(innerKey, innerEntity); 658 } 659 } 660 661 @Override 662 protected void addElement(Queue<Pair<T, I>> queue, T t) { 663 K outerKey = outerKeySelector.call(t); 664 I innerEntity = innerMap.get(outerKey); 665 666 if (innerEntity != null) { 667 queue.add(new Pair<T, I>(t, innerEntity)); 668 } 669 } 670 671 @Override 672 protected R toResult(Pair<T, I> e) { 673 return resultSelector.call(e.a, e.b); 674 } 675 }; 676 } 677 }); 678 } 679 680 public T last() { 681 Iterator<T> iterator = iterable.iterator(); 682 683 if (!iterator.hasNext()) { 684 throw new NoSuchElementException(); 685 } 686 687 T last = null; 688 689 while (iterator.hasNext()) { 690 last = iterator.next(); 691 } 692 693 return last; 694 } 695 696 public T last(Func<T, Boolean> predicate) { 697 T last = null; 698 boolean found = false; 699 700 for (T t : iterable) { 701 702 if (predicate.call(t)) { 703 last = t; 704 705 if (!found) { 706 found = true; 707 } 708 } 709 } 710 711 if (!found) { 712 throw new NoSuchElementException(); 713 } 714 715 return last; 716 } 717 718 public T lastOrDefault() { 719 return lastOrDefault((T) null); 720 } 721 722 public T lastOrDefault(T defaultValue) { 723 Iterator<T> iterator = iterable.iterator(); 724 725 if (!iterator.hasNext()) { 726 return defaultValue; 727 } 728 729 T last = null; 730 731 while (iterator.hasNext()) { 732 last = iterator.next(); 733 } 734 735 return last; 736 } 737 738 public T lastOrDefault(Func<T, Boolean> predicate) { 739 return lastOrDefault(predicate, null); 740 } 741 742 public T lastOrDefault(Func<T, Boolean> predicate, T defaultValue) { 743 T last = null; 744 boolean found = false; 745 746 for (T t : iterable) { 747 748 if (predicate.call(t)) { 749 last = t; 750 751 if (!found) { 752 found = true; 753 } 754 } 755 } 756 757 if (!found) { 758 return defaultValue; 759 } 760 761 return last; 762 } 763 764 public long longCount() { 765 long c = 0; 766 767 for (Iterator<T> it = iterable.iterator(); it.hasNext(); it.next()) { 768 c++; 769 } 770 771 return c; 772 } 773 774 public long longCount(Func<T, Boolean> predicate) { 775 long c = 0; 776 777 for (T t : iterable) { 778 779 if (predicate.call(t)) { 780 c++; 781 } 782 } 783 784 return c; 785 } 786 787 @SuppressWarnings("unchecked") 788 public T max() { 789 Iterator<T> iterator = iterable.iterator(); 790 T max = iterator.next(); 791 792 while (iterator.hasNext()) { 793 T t = iterator.next(); 794 795 if (((Comparable<T>) t).compareTo(max) > 0) { 796 max = t; 797 } 798 } 799 800 return max; 801 } 802 803 public <R extends Comparable<R>> R max(Func<T, R> selector) { 804 Iterator<T> iterator = iterable.iterator(); 805 R max = selector.call(iterator.next()); 806 807 while (iterator.hasNext()) { 808 R r = selector.call(iterator.next()); 809 810 if (r.compareTo(max) > 0) { 811 max = r; 812 } 813 } 814 815 return max; 816 } 817 818 @SuppressWarnings("unchecked") 819 public T min() { 820 Iterator<T> iterator = iterable.iterator(); 821 T min = iterator.next(); 822 823 while (iterator.hasNext()) { 824 T t = iterator.next(); 825 826 if (((Comparable<T>) t).compareTo(min) < 0) { 827 min = t; 828 } 829 } 830 831 return min; 832 } 833 834 public <R extends Comparable<R>> R min(Func<T, R> selector) { 835 Iterator<T> iterator = iterable.iterator(); 836 R min = selector.call(iterator.next()); 837 838 while (iterator.hasNext()) { 839 R r = selector.call(iterator.next()); 840 841 if (r.compareTo(min) < 0) { 842 min = r; 843 } 844 } 845 846 return min; 847 } 848 849 public <R> Enumerable<R> ofType(final Class<R> resultClass) { 850 return new BasicEnumerable<R>(new Iterable<R>() { 851 852 public Iterator<R> iterator() { 853 return new QueuedIterator<T, T, R>(iterable.iterator()) { 854 855 @Override 856 protected void addElement(Queue<T> queue, T t) { 857 858 if (resultClass.isInstance(t)) { 859 queue.add(t); 860 } 861 } 862 863 @Override 864 protected R toResult(T e) { 865 return resultClass.cast(e); 866 } 867 }; 868 } 869 }); 870 } 871 872 public <K> OrderedEnumerable<T> orderBy(Func<T, K> keySelector) { 873 return new BasicOrderedEnumerable<T>(this, keySelector, false); 874 } 875 876 public <K> OrderedEnumerable<T> orderBy(Func<T, K> keySelector, 877 Comparator<K> comparator) { 878 879 return new BasicOrderedEnumerable<T>(this, keySelector, false, 880 comparator); 881 } 882 883 public <K> OrderedEnumerable<T> orderByDescending(Func<T, K> keySelector) { 884 return new BasicOrderedEnumerable<T>(this, keySelector, true); 885 } 886 887 public <K> OrderedEnumerable<T> orderByDescending(Func<T, K> keySelector, 888 Comparator<K> comparator) { 889 890 return new BasicOrderedEnumerable<T>(this, keySelector, true, 891 comparator); 892 } 893 894 public static Enumerable<Integer> range(final int start, final int count) { 895 return new BasicEnumerable<Integer>(new Iterable<Integer>() { 896 897 public Iterator<Integer> iterator() { 898 899 return new Iterator<Integer>() { 900 901 private int index; 902 903 private int value = start; 904 905 public boolean hasNext() { 906 return index < count; 907 } 908 909 public Integer next() { 910 911 if (index >= count) { 912 throw new NoSuchElementException(); 913 } 914 915 index++; 916 return value++; 917 } 918 919 public void remove() { 920 throw new UnsupportedOperationException(); 921 } 922 }; 923 } 924 }); 925 } 926 927 public static <R> Enumerable<R> repeat(final R element, final int count) { 928 return new BasicEnumerable<R>(new Iterable<R>() { 929 930 public Iterator<R> iterator() { 931 932 return new Iterator<R>() { 933 934 private int index; 935 936 public boolean hasNext() { 937 return index < count; 938 } 939 940 public R next() { 941 942 if (index >= count) { 943 throw new NoSuchElementException(); 944 } 945 946 index++; 947 return element; 948 } 949 950 public void remove() { 951 throw new UnsupportedOperationException(); 952 } 953 }; 954 } 955 }); 956 } 957 958 public Enumerable<T> reverse() { 959 List<T> list = toList(); 960 Collections.reverse(list); 961 return new BasicEnumerable<T>(list); 962 } 963 964 public <R> Enumerable<R> select(final Func<T, R> selector) { 965 return new BasicEnumerable<R>(new Iterable<R>() { 966 967 public Iterator<R> iterator() { 968 969 return new Iterator<R>() { 970 971 private final Iterator<T> iterator = iterable.iterator(); 972 973 public boolean hasNext() { 974 return iterator.hasNext(); 975 } 976 977 public R next() { 978 return selector.call(iterator.next()); 979 } 980 981 public void remove() { 982 throw new UnsupportedOperationException(); 983 } 984 }; 985 } 986 }); 987 } 988 989 public <R> Enumerable<R> select(final Func2<T, Integer, R> selector) { 990 return select(new Func<T, R>() { 991 992 private int index; 993 994 public R call(T arg1) { 995 return selector.call(arg1, index++); 996 } 997 }); 998 } 999 1000 public <R> Enumerable<R> selectMany(Func<T, Enumerable<R>> selector) { 1001 return selectMany(selector, new Func2<T, R, R>() { 1002 1003 public R call(T arg1, R arg2) { 1004 return arg2; 1005 } 1006 }); 1007 } 1008 1009 public <C, R> Enumerable<R> selectMany( 1010 final Func<T, Enumerable<C>> collectionSelector, 1011 final Func2<T, C, R> resultSelector) { 1012 1013 return new BasicEnumerable<R>(new Iterable<R>() { 1014 1015 public Iterator<R> iterator() { 1016 return new QueuedIterator<T, Pair<T, C>, R>(iterable.iterator()) { 1017 1018 @Override 1019 protected void addElement(Queue<Pair<T, C>> queue, T t) { 1020 1021 for (C c : collectionSelector.call(t)) { 1022 queue.add(new Pair<T, C>(t, c)); 1023 } 1024 } 1025 1026 @Override 1027 protected R toResult(Pair<T, C> e) { 1028 return resultSelector.call(e.a, e.b); 1029 } 1030 }; 1031 } 1032 }); 1033 } 1034 1035 public <R> Enumerable<R> selectMany( 1036 Func2<T, Integer, Enumerable<R>> selector) { 1037 1038 return selectMany(selector, new Func2<T, R, R>() { 1039 1040 public R call(T arg1, R arg2) { 1041 return arg2; 1042 } 1043 }); 1044 } 1045 1046 public <C, R> Enumerable<R> selectMany( 1047 final Func2<T, Integer, Enumerable<C>> collectionSelector, 1048 Func2<T, C, R> resultSelector) { 1049 1050 return selectMany(new Func<T, Enumerable<C>>() { 1051 1052 private int index; 1053 1054 public Enumerable<C> call(T arg1) { 1055 return collectionSelector.call(arg1, index++); 1056 } 1057 }, resultSelector); 1058 } 1059 1060 public Boolean sequenceEqual(Enumerable<T> second) { 1061 Iterator<T> iterator = second.iterator(); 1062 1063 for (T f : iterable) { 1064 1065 if (!iterator.hasNext()) { 1066 return false; 1067 } 1068 1069 if (!equals(f, iterator.next())) { 1070 return false; 1071 } 1072 } 1073 1074 if (iterator.hasNext()) { 1075 return false; 1076 } 1077 1078 return true; 1079 } 1080 1081 public T single() { 1082 Iterator<T> iterator = iterable.iterator(); 1083 T t = iterator.next(); 1084 1085 if (iterator.hasNext()) { 1086 throw new NoSuchElementException(); 1087 } 1088 1089 return t; 1090 } 1091 1092 public T single(Func<T, Boolean> predicate) { 1093 T single = null; 1094 boolean found = false; 1095 1096 for (T t : iterable) { 1097 1098 if (predicate.call(t)) { 1099 1100 if (found) { 1101 found = false; 1102 break; 1103 } 1104 1105 single = t; 1106 found = true; 1107 } 1108 } 1109 1110 if (!found) { 1111 throw new NoSuchElementException(); 1112 } 1113 1114 return single; 1115 } 1116 1117 public T singleOrDefault() { 1118 return singleOrDefault((T) null); 1119 } 1120 1121 public T singleOrDefault(T defaultValue) { 1122 Iterator<T> iterator = iterable.iterator(); 1123 1124 if (!iterator.hasNext()) { 1125 return defaultValue; 1126 } 1127 1128 T t = iterator.next(); 1129 1130 if (iterator.hasNext()) { 1131 return defaultValue; 1132 } 1133 1134 return t; 1135 } 1136 1137 public T singleOrDefault(Func<T, Boolean> predicate) { 1138 return singleOrDefault(predicate, (T) null); 1139 } 1140 1141 public T singleOrDefault(Func<T, Boolean> predicate, T defaultValue) { 1142 T single = null; 1143 boolean found = false; 1144 1145 for (T t : iterable) { 1146 1147 if (predicate.call(t)) { 1148 1149 if (found) { 1150 found = false; 1151 break; 1152 } 1153 1154 single = t; 1155 found = true; 1156 } 1157 } 1158 1159 if (!found) { 1160 return defaultValue; 1161 } 1162 1163 return single; 1164 } 1165 1166 public Enumerable<T> skip(final int count) { 1167 return new BasicEnumerable<T>(new Iterable<T>() { 1168 1169 public Iterator<T> iterator() { 1170 return new Iterator<T>() { 1171 1172 private final Iterator<T> iterator = iterable.iterator(); 1173 1174 private boolean skipped; 1175 1176 private boolean skip() { 1177 1178 if (skipped) { 1179 return true; 1180 } 1181 1182 skipped = true; 1183 1184 for (int i = 0; i < count; i++) { 1185 1186 if (!iterator.hasNext()) { 1187 return false; 1188 } 1189 1190 iterator.next(); 1191 } 1192 1193 return true; 1194 } 1195 1196 public boolean hasNext() { 1197 1198 if (!skip()) { 1199 return false; 1200 } 1201 1202 return iterator.hasNext(); 1203 } 1204 1205 public T next() { 1206 1207 if (!skip()) { 1208 throw new NoSuchElementException(); 1209 } 1210 1211 return iterator.next(); 1212 } 1213 1214 public void remove() { 1215 throw new UnsupportedOperationException(); 1216 } 1217 }; 1218 } 1219 }); 1220 } 1221 1222 public Enumerable<T> skipWhile(final Func<T, Boolean> predicate) { 1223 return new BasicEnumerable<T>(new Iterable<T>() { 1224 1225 public Iterator<T> iterator() { 1226 return new QueuedIterator<T, T, T>(iterable.iterator()) { 1227 1228 private boolean skipped; 1229 1230 @Override 1231 protected void addElement(Queue<T> queue, T t) { 1232 1233 if (!skipped) { 1234 1235 if (predicate.call(t)) { 1236 return; 1237 } 1238 1239 skipped = true; 1240 } 1241 1242 queue.add(t); 1243 } 1244 1245 @Override 1246 protected T toResult(T e) { 1247 return e; 1248 } 1249 }; 1250 } 1251 }); 1252 } 1253 1254 public Enumerable<T> skipWhile(final Func2<T, Integer, Boolean> predicate) { 1255 return skipWhile(new Func<T, Boolean>() { 1256 1257 private int index; 1258 1259 public Boolean call(T arg1) { 1260 return predicate.call(arg1, index++); 1261 } 1262 }); 1263 } 1264 1265 public int sum() { 1266 int sum = 0; 1267 1268 for (T t : iterable) { 1269 sum += (Integer) t; 1270 } 1271 1272 return sum; 1273 } 1274 1275 public long sumLong() { 1276 long sum = 0; 1277 1278 for (T t : iterable) { 1279 sum += (Long) t; 1280 } 1281 1282 return sum; 1283 } 1284 1285 public float sumFloat() { 1286 float sum = 0; 1287 1288 for (T t : iterable) { 1289 sum += (Float) t; 1290 } 1291 1292 return sum; 1293 } 1294 1295 public double sumDouble() { 1296 double sum = 0; 1297 1298 for (T t : iterable) { 1299 sum += (Double) t; 1300 } 1301 1302 return sum; 1303 } 1304 1305 public int sum(Func<T, Integer> selector) { 1306 int sum = 0; 1307 1308 for (T t : iterable) { 1309 sum += selector.call(t); 1310 } 1311 1312 return sum; 1313 } 1314 1315 public long sumLong(Func<T, Long> selector) { 1316 long sum = 0; 1317 1318 for (T t : iterable) { 1319 sum += selector.call(t); 1320 } 1321 1322 return sum; 1323 } 1324 1325 public float sumFloat(Func<T, Float> selector) { 1326 float sum = 0; 1327 1328 for (T t : iterable) { 1329 sum += selector.call(t); 1330 } 1331 1332 return sum; 1333 } 1334 1335 public double sumDouble(Func<T, Double> selector) { 1336 double sum = 0; 1337 1338 for (T t : iterable) { 1339 sum += selector.call(t); 1340 } 1341 1342 return sum; 1343 } 1344 1345 public Enumerable<T> take(final int count) { 1346 return new BasicEnumerable<T>(new Iterable<T>() { 1347 1348 public Iterator<T> iterator() { 1349 return new Iterator<T>() { 1350 1351 private final Iterator<T> iterator = iterable.iterator(); 1352 1353 private int index; 1354 1355 public boolean hasNext() { 1356 1357 if (index >= count) { 1358 return false; 1359 } 1360 1361 return iterator.hasNext(); 1362 } 1363 1364 public T next() { 1365 1366 if (index >= count) { 1367 throw new NoSuchElementException(); 1368 } 1369 1370 index++; 1371 return iterator.next(); 1372 } 1373 1374 public void remove() { 1375 throw new UnsupportedOperationException(); 1376 } 1377 }; 1378 } 1379 }); 1380 } 1381 1382 public Enumerable<T> takeWhile(final Func<T, Boolean> predicate) { 1383 return new BasicEnumerable<T>(new Iterable<T>() { 1384 1385 public Iterator<T> iterator() { 1386 return new QueuedIterator<T, T, T>(iterable.iterator()) { 1387 1388 private boolean done; 1389 1390 @Override 1391 protected void addElement(Queue<T> queue, T t) { 1392 1393 if (done) { 1394 return; 1395 } 1396 1397 if (!predicate.call(t)) { 1398 done = true; 1399 return; 1400 } 1401 1402 queue.add(t); 1403 } 1404 1405 @Override 1406 protected T toResult(T e) { 1407 return e; 1408 } 1409 }; 1410 } 1411 }); 1412 } 1413 1414 public Enumerable<T> takeWhile(final Func2<T, Integer, Boolean> predicate) { 1415 return takeWhile(new Func<T, Boolean>() { 1416 1417 private int index; 1418 1419 public Boolean call(T arg1) { 1420 return predicate.call(arg1, index++); 1421 } 1422 }); 1423 } 1424 1425 public Object[] toArray() { 1426 return toList().toArray(); 1427 } 1428 1429 @SuppressWarnings("unchecked") 1430 public <R> R[] toArray(Class<R> resultClass) { 1431 List<T> list = toList(); 1432 R[] array = (R[]) Array.newInstance(resultClass, list.size()); 1433 return list.toArray(array); 1434 } 1435 1436 public List<T> toList() { 1437 ArrayList<T> list = new ArrayList<T>(); 1438 1439 for (T e : iterable) { 1440 list.add(e); 1441 } 1442 1443 return list; 1444 } 1445 1446 public EnumerableList<T> toEnumerableList() { 1447 return new BasicEnumerableList<T>(toList()); 1448 } 1449 1450 public <K> Map<K, List<T>> toListMap(Func<T, K> keySelector) { 1451 return toListMap(keySelector, getPassThroughFunc()); 1452 } 1453 1454 public <K, E> Map<K, List<E>> toListMap(Func<T, K> keySelector, 1455 Func<T, E> elementSelector) { 1456 1457 Map<K, List<E>> map = new LinkedHashMap<K, List<E>>(); 1458 1459 for (T t : iterable) { 1460 K k = keySelector.call(t); 1461 List<E> list = map.get(k); 1462 1463 if (list == null) { 1464 list = new ArrayList<E>(); 1465 map.put(k, list); 1466 } 1467 1468 list.add(elementSelector.call(t)); 1469 } 1470 1471 return map; 1472 } 1473 1474 public <K> Lookup<K, T> toLookup(Func<T, K> keySelector) { 1475 return toLookup(keySelector, getPassThroughFunc()); 1476 } 1477 1478 public <K, E> Lookup<K, E> toLookup(Func<T, K> keySelector, 1479 Func<T, E> elementSelector) { 1480 1481 return new BasicLookup<K, E>(toListMap(keySelector, elementSelector)); 1482 } 1483 1484 public <K> Map<K, T> toMap(Func<T, K> keySelector) { 1485 return toMap(keySelector, getPassThroughFunc()); 1486 } 1487 1488 public <K, E> Map<K, E> toMap(Func<T, K> keySelector, 1489 Func<T, E> elementSelector) { 1490 1491 Map<K, E> map = new LinkedHashMap<K, E>(); 1492 1493 for (T t : iterable) { 1494 K k = keySelector.call(t); 1495 1496 if (map.containsKey(k)) { 1497 throw new IllegalArgumentException(); 1498 } 1499 1500 map.put(k, elementSelector.call(t)); 1501 } 1502 1503 return map; 1504 } 1505 1506 public <K> Dictionary<K, T> toDictionary(Func<T, K> keySelector) { 1507 return toDictionary(keySelector, getPassThroughFunc()); 1508 } 1509 1510 public <K, E> Dictionary<K, E> toDictionary(Func<T, K> keySelector, 1511 Func<T, E> elementSelector) { 1512 1513 return new BasicDictionary<K, E>(toMap(keySelector, elementSelector)); 1514 } 1515 1516 public Enumerable<T> union(final Enumerable<T> second) { 1517 return new BasicEnumerable<T>(new Iterable<T>() { 1518 1519 public Iterator<T> iterator() { 1520 return new QueuedIterator<T, T, T>(new ConcatenatedIterator<T>( 1521 iterable.iterator(), second.iterator())) { 1522 1523 private final Set<T> set = new HashSet<T>(); 1524 1525 @Override 1526 protected void addElement(Queue<T> queue, T t) { 1527 1528 if (!set.contains(t)) { 1529 queue.add(t); 1530 set.add(t); 1531 } 1532 } 1533 1534 @Override 1535 protected T toResult(T e) { 1536 return e; 1537 } 1538 }; 1539 } 1540 }); 1541 } 1542 1543 public Enumerable<T> where(final Func<T, Boolean> predicate) { 1544 return new BasicEnumerable<T>(new Iterable<T>() { 1545 1546 public Iterator<T> iterator() { 1547 return new QueuedIterator<T, T, T>(iterable.iterator()) { 1548 1549 @Override 1550 protected void addElement(Queue<T> queue, T t) { 1551 1552 if (predicate.call(t)) { 1553 queue.add(t); 1554 } 1555 } 1556 1557 @Override 1558 protected T toResult(T e) { 1559 return e; 1560 } 1561 }; 1562 } 1563 }); 1564 } 1565 1566 public Enumerable<T> where(final Func2<T, Integer, Boolean> predicate) { 1567 return where(new Func<T, Boolean>() { 1568 1569 private int index; 1570 1571 public Boolean call(T arg1) { 1572 return predicate.call(arg1, index++); 1573 } 1574 }); 1575 } 1576 1577 private Func<T, T> getPassThroughFunc() { 1578 return new Func<T, T>() { 1579 1580 public T call(T arg1) { 1581 return arg1; 1582 } 1583 }; 1584 } 1585 }