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