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