Java API By Example, From Geeks To Geeks.

1 /* 2  * Primitive Collections for Java. 3  * Copyright (C) 2002, 2003 Søren Bak 4  * 5  * This library is free software; you can redistribute it and/or 6  * modify it under the terms of the GNU Lesser General Public 7  * License as published by the Free Software Foundation; either 8  * version 2.1 of the License, or (at your option) any later version. 9  * 10  * This library is distributed in the hope that it will be useful, 11  * but WITHOUT ANY WARRANTY; without even the implied warranty of 12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13  * Lesser General Public License for more details. 14  * 15  * You should have received a copy of the GNU Lesser General Public 16  * License along with this library; if not, write to the Free Software 17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18  */ 19 package bak.pcj; 20 21 import bak.pcj.list.*; 22 import bak.pcj.set.*; 23 import bak.pcj.map.*; 24 import bak.pcj.adapter.*; 25 import java.util.Collection ; 26 import java.util.Iterator ; 27 import java.util.List ; 28 import java.util.ListIterator ; 29 import java.util.Set ; 30 import java.util.SortedSet ; 31 import java.util.Map ; 32 33 /** 34  * This class provides static methods for creating adapters betweeen 35  * primitive collections and Java Collection Framework collections. 36  * Adapters are generally implemented as wrappers around an underlying 37  * collection. Thus, changes to the underlying collection are reflected 38  * by the adapting collection and vice versa. 39  * 40  * <p>In order for adaptions from JCF to PCJ to work correctly, 41  * a number of rules should be followed: 42  * <ul> 43  * <li>The underlying java.util collection/iterator should only 44  * contain values of the class representing the primitive type 45  * of the adapting collection/iterator. E.g. if a <tt>List</tt> is adapted 46  * to a <tt>FloatCollection</tt>, the <tt>List</tt> can only contain 47  * values of class <tt>Float</tt>. If this rule is not followed, a 48  * {@link ClassCastException ClassCastException} will likely be 49  * thrown by some or all of the adaption's methods. 50  * <li>The underlying java.util collection/iterator should not 51  * contain <tt>null</tt>-values. If this rule is not followed, a 52  * {@link NullPointerException NullPointerException} will likely be 53  * thrown by some or all of the adaption's methods. 54  * </ul> 55  * The adapter classes from JCF to PCJ all contains validation methods 56  * to ensure that these rules are followed, and a number of static methods 57  * is available in this class to check whether a JCF collection is 58  * adaptable (<tt>isTAdaptable(Collection)</tt>, <tt>isTKeyAdaptable(Map)</tt>, 59  * and <tt>isTKeySAdaptable(Map)</tt>). 60  * 61  * @author S&oslash;ren Bak 62  * @version 1.3 18-08-2003 23:53 63  * @since 1.0 64  */ 65 public class Adapter { 66 67     /** Prevents instantiation. */ 68     private Adapter() { } 69 70     // --------------------------------------------------------------- 71 // Iterator -> TIterator 72 // --------------------------------------------------------------- 73 74     /** 75      * Returns an adaption of an iterator to an iterator over 76      * primitive boolean values. 77      * 78      * @param iterator 79      * the iterator to adapt. 80      * 81      * @return an adaption of an iterator to an iterator over 82      * primitive boolean values. 83      */ 84     public static BooleanIterator asBooleans(Iterator iterator) 85     { return new IteratorToBooleanIteratorAdapter(iterator); } 86 87     /** 88      * Returns an adaption of an iterator to an iterator over 89      * primitive char values. 90      * 91      * @return an adaption of an iterator to an iterator over 92      * primitive char values. 93      */ 94     public static CharIterator asChars(Iterator iterator) 95     { return new IteratorToCharIteratorAdapter(iterator); } 96 97     /** 98      * Returns an adaption of an iterator to an iterator over 99      * primitive byte values. 100      * 101      * @param iterator 102      * the iterator to adapt. 103      * 104      * @return an adaption of an iterator to an iterator over 105      * primitive byte values. 106      */ 107     public static ByteIterator asBytes(Iterator iterator) 108     { return new IteratorToByteIteratorAdapter(iterator); } 109 110     /** 111      * Returns an adaption of an iterator to an iterator over 112      * primitive short values. 113      * 114      * @param iterator 115      * the iterator to adapt. 116      * 117      * @return an adaption of an iterator to an iterator over 118      * primitive short values. 119      */ 120     public static ShortIterator asShorts(Iterator iterator) 121     { return new IteratorToShortIteratorAdapter(iterator); } 122 123     /** 124      * Returns an adaption of an iterator to an iterator over 125      * primitive int values. 126      * 127      * @param iterator 128      * the iterator to adapt. 129      * 130      * @return an adaption of an iterator to an iterator over 131      * primitive int values. 132      */ 133     public static IntIterator asInts(Iterator iterator) 134     { return new IteratorToIntIteratorAdapter(iterator); } 135 136     /** 137      * Returns an adaption of an iterator to an iterator over 138      * primitive long values. 139      * 140      * @param iterator 141      * the iterator to adapt. 142      * 143      * @return an adaption of an iterator to an iterator over 144      * primitive long values. 145      */ 146     public static LongIterator asLongs(Iterator iterator) 147     { return new IteratorToLongIteratorAdapter(iterator); } 148 149     /** 150      * Returns an adaption of an iterator to an iterator over 151      * primitive float values. 152      * 153      * @param iterator 154      * the iterator to adapt. 155      * 156      * @return an adaption of an iterator to an iterator over 157      * primitive float values. 158      */ 159     public static FloatIterator asFloats(Iterator iterator) 160     { return new IteratorToFloatIteratorAdapter(iterator); } 161 162     /** 163      * Returns an adaption of an iterator to an iterator over 164      * primitive double values. 165      * 166      * @param iterator 167      * the iterator to adapt. 168      * 169      * @return an adaption of an iterator to an iterator over 170      * primitive double values. 171      */ 172     public static DoubleIterator asDoubles(Iterator iterator) 173     { return new IteratorToDoubleIteratorAdapter(iterator); } 174 175     // --------------------------------------------------------------- 176 // TIterator -> Iterator 177 // --------------------------------------------------------------- 178 179     /** 180      * Returns an adaption of an iterator over primitive 181      * boolean values to an iterator. 182      * 183      * @param iterator 184      * the iterator to adapt. 185      * 186      * @return an adaption of an iterator over primitive 187      * boolean values to an iterator. 188      */ 189     public static Iterator asObjects(BooleanIterator iterator) 190     { return new BooleanIteratorToIteratorAdapter(iterator); } 191 192     /** 193      * Returns an adaption of an iterator over primitive 194      * char values to an iterator. 195      * 196      * @param iterator 197      * the iterator to adapt. 198      * 199      * @return an adaption of an iterator over primitive 200      * char values to an iterator. 201      */ 202     public static Iterator asObjects(CharIterator iterator) 203     { return new CharIteratorToIteratorAdapter(iterator); } 204 205     /** 206      * Returns an adaption of an iterator over primitive 207      * byte values to an iterator. 208      * 209      * @param iterator 210      * the iterator to adapt. 211      * 212      * @return an adaption of an iterator over primitive 213      * byte values to an iterator. 214      */ 215     public static Iterator asObjects(ByteIterator iterator) 216     { return new ByteIteratorToIteratorAdapter(iterator); } 217 218     /** 219      * Returns an adaption of an iterator over primitive 220      * short values to an iterator. 221      * 222      * @param iterator 223      * the iterator to adapt. 224      * 225      * @return an adaption of an iterator over primitive 226      * short values to an iterator. 227      */ 228     public static Iterator asObjects(ShortIterator iterator) 229     { return new ShortIteratorToIteratorAdapter(iterator); } 230 231     /** 232      * Returns an adaption of an iterator over primitive 233      * int values to an iterator. 234      * 235      * @param iterator 236      * the iterator to adapt. 237      * 238      * @return an adaption of an iterator over primitive 239      * int values to an iterator. 240      */ 241     public static Iterator asObjects(IntIterator iterator) 242     { return new IntIteratorToIteratorAdapter(iterator); } 243 244     /** 245      * Returns an adaption of an iterator over primitive 246      * long values to an iterator. 247      * 248      * @param iterator 249      * the iterator to adapt. 250      * 251      * @return an adaption of an iterator over primitive 252      * long values to an iterator. 253      */ 254     public static Iterator asObjects(LongIterator iterator) 255     { return new LongIteratorToIteratorAdapter(iterator); } 256 257     /** 258      * Returns an adaption of an iterator over primitive 259      * float values to an iterator. 260      * 261      * @param iterator 262      * the iterator to adapt. 263      * 264      * @return an adaption of an iterator over primitive 265      * float values to an iterator. 266      */ 267     public static Iterator asObjects(FloatIterator iterator) 268     { return new FloatIteratorToIteratorAdapter(iterator); } 269 270     /** 271      * Returns an adaption of an iterator over primitive 272      * double values to an iterator. 273      * 274      * @param iterator 275      * the iterator to adapt. 276      * 277      * @return an adaption of an iterator over primitive 278      * double values to an iterator. 279      */ 280     public static Iterator asObjects(DoubleIterator iterator) 281     { return new DoubleIteratorToIteratorAdapter(iterator); } 282 283     // --------------------------------------------------------------- 284 // Collection -> TCollection 285 // --------------------------------------------------------------- 286 287     /** 288      * Returns an adaption of a collection to a collection of 289      * primitive boolean values. 290      * 291      * @param collection 292      * the collection to adapt. 293      * 294      * @return an adaption of a collection to a collection of 295      * primitive boolean values. 296      */ 297     public static BooleanCollection asBooleans(Collection collection) 298     { return new CollectionToBooleanCollectionAdapter(collection); } 299 300     /** 301      * Returns an adaption of a collection to a collection of 302      * primitive char values. 303      * 304      * @param collection 305      * the collection to adapt. 306      * 307      * @return an adaption of a collection to a collection of 308      * primitive char values. 309      */ 310     public static CharCollection asChars(Collection collection) 311     { return new CollectionToCharCollectionAdapter(collection); } 312 313     /** 314      * Returns an adaption of a collection to a collection of 315      * primitive byte values. 316      * 317      * @param collection 318      * the collection to adapt. 319      * 320      * @return an adaption of a collection to a collection of 321      * primitive byte values. 322      */ 323     public static ByteCollection asBytes(Collection collection) 324     { return new CollectionToByteCollectionAdapter(collection); } 325 326     /** 327      * Returns an adaption of a collection to a collection of 328      * primitive short values. 329      * 330      * @param collection 331      * the collection to adapt. 332      * 333      * @return an adaption of a collection to a collection of 334      * primitive short values. 335      */ 336     public static ShortCollection asShorts(Collection collection) 337     { return new CollectionToShortCollectionAdapter(collection); } 338 339     /** 340      * Returns an adaption of a collection to a collection of 341      * primitive int values. 342      * 343      * @param collection 344      * the collection to adapt. 345      * 346      * @return an adaption of a collection to a collection of 347      * primitive int values. 348      */ 349     public static IntCollection asInts(Collection collection) 350     { return new CollectionToIntCollectionAdapter(collection); } 351 352     /** 353      * Returns an adaption of a collection to a collection of 354      * primitive long values. 355      * 356      * @param collection 357      * the collection to adapt. 358      * 359      * @return an adaption of a collection to a collection of 360      * primitive long values. 361      */ 362     public static LongCollection asLongs(Collection collection) 363     { return new CollectionToLongCollectionAdapter(collection); } 364 365     /** 366      * Returns an adaption of a collection to a collection of 367      * primitive float values. 368      * 369      * @param collection 370      * the collection to adapt. 371      * 372      * @return an adaption of a collection to a collection of 373      * primitive float values. 374      */ 375     public static FloatCollection asFloats(Collection collection) 376     { return new CollectionToFloatCollectionAdapter(collection); } 377 378     /** 379      * Returns an adaption of a collection to a collection of 380      * primitive double values. 381      * 382      * @param collection 383      * the collection to adapt. 384      * 385      * @return an adaption of a collection to a collection of 386      * primitive double values. 387      */ 388     public static DoubleCollection asDoubles(Collection collection) 389     { return new CollectionToDoubleCollectionAdapter(collection); } 390 391     // --------------------------------------------------------------- 392 // TCollection -> Collection 393 // --------------------------------------------------------------- 394 395     /** 396      * Returns an adaption of a primitive collection of boolean values 397      * to a collection. 398      * 399      * @param collection 400      * the collection to adapt. 401      * 402      * @return an adaption of a primitive collection of boolean 403      * values to a collection. 404      */ 405     public static Collection asObjects(BooleanCollection collection) 406     { return new BooleanCollectionToCollectionAdapter(collection); } 407 408     /** 409      * Returns an adaption of a primitive collection of char values 410      * to a collection. 411      * 412      * @param collection 413      * the collection to adapt. 414      * 415      * @return an adaption of a primitive collection of char 416      * values to a collection. 417      */ 418     public static Collection asObjects(CharCollection collection) 419     { return new CharCollectionToCollectionAdapter(collection); } 420 421     /** 422      * Returns an adaption of a primitive collection of byte values 423      * to a collection. 424      * 425      * @param collection 426      * the collection to adapt. 427      * 428      * @return an adaption of a primitive collection of byte 429      * values to a collection. 430      */ 431     public static Collection asObjects(ByteCollection collection) 432     { return new ByteCollectionToCollectionAdapter(collection); } 433 434     /** 435      * Returns an adaption of a primitive collection of short values 436      * to a collection. 437      * 438      * @param collection 439      * the collection to adapt. 440      * 441      * @return an adaption of a primitive collection of short 442      * values to a collection. 443      */ 444     public static Collection asObjects(ShortCollection collection) 445     { return new ShortCollectionToCollectionAdapter(collection); } 446 447     /** 448      * Returns an adaption of a primitive collection of int values 449      * to a collection. 450      * 451      * @param collection 452      * the collection to adapt. 453      * 454      * @return an adaption of a primitive collection of int 455      * values to a collection. 456      */ 457     public static Collection asObjects(IntCollection collection) 458     { return new IntCollectionToCollectionAdapter(collection); } 459 460     /** 461      * Returns an adaption of a primitive collection of long values 462      * to a collection. 463      * 464      * @param collection 465      * the collection to adapt. 466      * 467      * @return an adaption of a primitive collection of long 468      * values to a collection. 469      */ 470     public static Collection asObjects(LongCollection collection) 471     { return new LongCollectionToCollectionAdapter(collection); } 472 473     /** 474      * Returns an adaption of a primitive collection of float values 475      * to a collection. 476      * 477      * @param collection 478      * the collection to adapt. 479      * 480      * @return an adaption of a primitive collection of float 481      * values to a collection. 482      */ 483     public static Collection asObjects(FloatCollection collection) 484     { return new FloatCollectionToCollectionAdapter(collection); } 485 486     /** 487      * Returns an adaption of a primitive collection of double values 488      * to a collection. 489      * 490      * @param collection 491      * the collection to adapt. 492      * 493      * @return an adaption of a primitive collection of double 494      * values to a collection. 495      */ 496     public static Collection asObjects(DoubleCollection collection) 497     { return new DoubleCollectionToCollectionAdapter(collection); } 498 499     // --------------------------------------------------------------- 500 // ListIterator -> TListIterator 501 // --------------------------------------------------------------- 502 503     /** 504      * Returns an adaption of a list iterator to a list iterator over 505      * primitive boolean values. 506      * 507      * @param iterator 508      * the list iterator to adapt. 509      * 510      * @return an adaption of a list iterator to a list iterator over 511      * primitive boolean values. 512      */ 513     public static BooleanListIterator asBooleans(ListIterator iterator) 514     { return new ListIteratorToBooleanListIteratorAdapter(iterator); } 515 516     /** 517      * Returns an adaption of a list iterator to a list iterator over 518      * primitive char values. 519      * 520      * @param iterator 521      * the list iterator to adapt. 522      * 523      * @return an adaption of a list iterator to a list iterator over 524      * primitive char values. 525      */ 526     public static CharListIterator asChars(ListIterator iterator) 527     { return new ListIteratorToCharListIteratorAdapter(iterator); } 528 529     /** 530      * Returns an adaption of a list iterator to a list iterator over 531      * primitive byte values. 532      * 533      * @param iterator 534      * the list iterator to adapt. 535      * 536      * @return an adaption of a list iterator to a list iterator over 537      * primitive byte values. 538      */ 539     public static ByteListIterator asBytes(ListIterator iterator) 540     { return new ListIteratorToByteListIteratorAdapter(iterator); } 541 542     /** 543      * Returns an adaption of a list iterator to a list iterator over 544      * primitive short values. 545      * 546      * @param iterator 547      * the list iterator to adapt. 548      * 549      * @return an adaption of a list iterator to a list iterator over 550      * primitive short values. 551      */ 552     public static ShortListIterator asShorts(ListIterator iterator) 553     { return new ListIteratorToShortListIteratorAdapter(iterator); } 554 555     /** 556      * Returns an adaption of a list iterator to a list iterator over 557      * primitive int values. 558      * 559      * @param iterator 560      * the list iterator to adapt. 561      * 562      * @return an adaption of a list iterator to a list iterator over 563      * primitive int values. 564      */ 565     public static IntListIterator asInts(ListIterator iterator) 566     { return new ListIteratorToIntListIteratorAdapter(iterator); } 567 568     /** 569      * Returns an adaption of a list iterator to a list iterator over 570      * primitive long values. 571      * 572      * @param iterator 573      * the list iterator to adapt. 574      * 575      * @return an adaption of a list iterator to a list iterator over 576      * primitive long values. 577      */ 578     public static LongListIterator asLongs(ListIterator iterator) 579     { return new ListIteratorToLongListIteratorAdapter(iterator); } 580 581     /** 582      * Returns an adaption of a list iterator to a list iterator over 583      * primitive float values. 584      * 585      * @param iterator 586      * the list iterator to adapt. 587      * 588      * @return an adaption of a list iterator to a list iterator over 589      * primitive float values. 590      */ 591     public static FloatListIterator asFloats(ListIterator iterator) 592     { return new ListIteratorToFloatListIteratorAdapter(iterator); } 593 594     /** 595      * Returns an adaption of a list iterator to a list iterator over 596      * primitive double values. 597      * 598      * @param iterator 599      * the list iterator to adapt. 600      * 601      * @return an adaption of a list iterator to a list iterator over 602      * primitive double values. 603      */ 604     public static DoubleListIterator asDoubles(ListIterator iterator) 605     { return new ListIteratorToDoubleListIteratorAdapter(iterator); } 606 607     // --------------------------------------------------------------- 608 // TListIterator -> ListIterator 609 // --------------------------------------------------------------- 610 611     /** 612      * Returns an adaption of a list iterator over 613      * primitive boolean values to a list iterator. 614      * 615      * @param iterator 616      * the list iterator to adapt. 617      * 618      * @return an adaption of a list iterator over 619      * primitive boolean values to a list iterator. 620      */ 621     public static ListIterator asObjects(BooleanListIterator iterator) 622     { return new BooleanListIteratorToListIteratorAdapter(iterator); } 623 624     /** 625      * Returns an adaption of a list iterator over 626      * primitive char values to a list iterator. 627      * 628      * @param iterator 629      * the list iterator to adapt. 630      * 631      * @return an adaption of a list iterator over 632      * primitive char values to a list iterator. 633      */ 634     public static ListIterator asObjects(CharListIterator iterator) 635     { return new CharListIteratorToListIteratorAdapter(iterator); } 636 637     /** 638      * Returns an adaption of a list iterator over 639      * primitive byte values to a list iterator. 640      * 641      * @param iterator 642      * the list iterator to adapt. 643      * 644      * @return an adaption of a list iterator over 645      * primitive byte values to a list iterator. 646      */ 647     public static ListIterator asObjects(ByteListIterator iterator) 648     { return new ByteListIteratorToListIteratorAdapter(iterator); } 649 650     /** 651      * Returns an adaption of a list iterator over 652      * primitive short values to a list iterator. 653      * 654      * @param iterator 655      * the list iterator to adapt. 656      * 657      * @return an adaption of a list iterator over 658      * primitive short values to a list iterator. 659      */ 660     public static ListIterator asObjects(ShortListIterator iterator) 661     { return new ShortListIteratorToListIteratorAdapter(iterator); } 662 663     /** 664      * Returns an adaption of a list iterator over 665      * primitive int values to a list iterator. 666      * 667      * @param iterator 668      * the list iterator to adapt. 669      * 670      * @return an adaption of a list iterator over 671      * primitive int values to a list iterator. 672      */ 673     public static ListIterator asObjects(IntListIterator iterator) 674     { return new IntListIteratorToListIteratorAdapter(iterator); } 675 676     /** 677      * Returns an adaption of a list iterator over 678      * primitive long values to a list iterator. 679      * 680      * @param iterator 681      * the list iterator to adapt. 682      * 683      * @return an adaption of a list iterator over 684      * primitive long values to a list iterator. 685      */ 686     public static ListIterator asObjects(LongListIterator iterator) 687     { return new LongListIteratorToListIteratorAdapter(iterator); } 688 689     /** 690      * Returns an adaption of a list iterator over 691      * primitive float values to a list iterator. 692      * 693      * @param iterator 694      * the list iterator to adapt. 695      * 696      * @return an adaption of a list iterator over 697      * primitive float values to a list iterator. 698      */ 699     public static ListIterator asObjects(FloatListIterator iterator) 700     { return new FloatListIteratorToListIteratorAdapter(iterator); } 701 702     /** 703      * Returns an adaption of a list iterator over 704      * primitive double values to a list iterator. 705      * 706      * @param iterator 707      * the list iterator to adapt. 708      * 709      * @return an adaption of a list iterator over 710      * primitive double values to a list iterator. 711      */ 712     public static ListIterator asObjects(DoubleListIterator iterator) 713     { return new DoubleListIteratorToListIteratorAdapter(iterator); } 714 715     // --------------------------------------------------------------- 716 // Set -> TSet 717 // --------------------------------------------------------------- 718 719     /** 720      * Returns an adaption of a set to a set of 721      * primitive boolean values. 722      * 723      * @param set 724      * the set to adapt. 725      * 726      * @return an adaption of a set to a set of 727      * primitive boolean values. 728      */ 729     public static BooleanSet asBooleans(Set set) 730     { return new SetToBooleanSetAdapter(set); } 731 732     /** 733      * Returns an adaption of a set to a set of 734      * primitive char values. 735      * 736      * @param set 737      * the set to adapt. 738      * 739      * @return an adaption of a set to a set of 740      * primitive char values. 741      */ 742     public static CharSet asChars(Set set) 743     { return new SetToCharSetAdapter(set); } 744 745     /** 746      * Returns an adaption of a set to a set of 747      * primitive byte values. 748      * 749      * @param set 750      * the set to adapt. 751      * 752      * @return an adaption of a set to a set of 753      * primitive byte values. 754      */ 755     public static ByteSet asBytes(Set set) 756     { return new SetToByteSetAdapter(set); } 757 758     /** 759      * Returns an adaption of a set to a set of 760      * primitive short values. 761      * 762      * @param set 763      * the set to adapt. 764      * 765      * @return an adaption of a set to a set of 766      * primitive short values. 767      */ 768     public static ShortSet asShorts(Set set) 769     { return new SetToShortSetAdapter(set); } 770 771     /** 772      * Returns an adaption of a set to a set of 773      * primitive int values. 774      * 775      * @param set 776      * the set to adapt. 777      * 778      * @return an adaption of a set to a set of 779      * primitive int values. 780      */ 781     public static IntSet asInts(Set set) 782     { return new SetToIntSetAdapter(set); } 783 784     /** 785      * Returns an adaption of a set to a set of 786      * primitive long values. 787      * 788      * @param set 789      * the set to adapt. 790      * 791      * @return an adaption of a set to a set of 792      * primitive long values. 793      */ 794     public static LongSet asLongs(Set set) 795     { return new SetToLongSetAdapter(set); } 796 797     /** 798      * Returns an adaption of a set to a set of 799      * primitive float values. 800      * 801      * @param set 802      * the set to adapt. 803      * 804      * @return an adaption of a set to a set of 805      * primitive float values. 806      */ 807     public static FloatSet asFloats(Set set) 808     { return new SetToFloatSetAdapter(set); } 809 810     /** 811      * Returns an adaption of a set to a set of 812      * primitive double values. 813      * 814      * @param set 815      * the set to adapt. 816      * 817      * @return an adaption of a set to a set of 818      * primitive double values. 819      */ 820     public static DoubleSet asDoubles(Set set) 821     { return new SetToDoubleSetAdapter(set); } 822 823     // --------------------------------------------------------------- 824 // TSet -> Set 825 // --------------------------------------------------------------- 826 827     /** 828      * Returns an adaption of a set of primitive boolean values 829      * to a set. 830      * 831      * @param set 832      * the set to adapt. 833      * 834      * @return an adaption of a set of primitive boolean values 835      * to a set. 836      */ 837     public static Set asObjects(BooleanSet set) 838     { return new BooleanSetToSetAdapter(set); } 839 840     /** 841      * Returns an adaption of a set of primitive char values 842      * to a set. 843      * 844      * @param set 845      * the set to adapt. 846      * 847      * @return an adaption of a set of primitive char values 848      * to a set. 849      */ 850     public static Set asObjects(CharSet set) 851     { return new CharSetToSetAdapter(set); } 852 853     /** 854      * Returns an adaption of a set of primitive byte values 855      * to a set. 856      * 857      * @param set 858      * the set to adapt. 859      * 860      * @return an adaption of a set of primitive byte values 861      * to a set. 862      */ 863     public static Set asObjects(ByteSet set) 864     { return new ByteSetToSetAdapter(set); } 865 866     /** 867      * Returns an adaption of a set of primitive short values 868      * to a set. 869      * 870      * @param set 871      * the set to adapt. 872      * 873      * @return an adaption of a set of primitive short values 874      * to a set. 875      */ 876     public static Set asObjects(ShortSet set) 877     { return new ShortSetToSetAdapter(set); } 878 879     /** 880      * Returns an adaption of a set of primitive int values 881      * to a set. 882      * 883      * @param set 884      * the set to adapt. 885      * 886      * @return an adaption of a set of primitive int values 887      * to a set. 888      */ 889     public static Set asObjects(IntSet set) 890     { return new IntSetToSetAdapter(set); } 891 892     /** 893      * Returns an adaption of a set of primitive long values 894      * to a set. 895      * 896      * @param set 897      * the set to adapt. 898      * 899      * @return an adaption of a set of primitive long values 900      * to a set. 901      */ 902     public static Set asObjects(LongSet set) 903     { return new LongSetToSetAdapter(set); } 904 905     /** 906      * Returns an adaption of a set of primitive float values 907      * to a set. 908      * 909      * @param set 910      * the set to adapt. 911      * 912      * @return an adaption of a set of primitive float values 913      * to a set. 914      */ 915     public static Set asObjects(FloatSet set) 916     { return new FloatSetToSetAdapter(set); } 917 918     /** 919      * Returns an adaption of a set of primitive double values 920      * to a set. 921      * 922      * @param set 923      * the set to adapt. 924      * 925      * @return an adaption of a set of primitive double values 926      * to a set. 927      */ 928     public static Set asObjects(DoubleSet set) 929     { return new DoubleSetToSetAdapter(set); } 930 931     // --------------------------------------------------------------- 932 // SortedSet -> TSortedSet 933 // --------------------------------------------------------------- 934 935     /** 936      * Returns an adaption of a sorted set to a sorted set of 937      * primitive boolean values. 938      * 939      * @param set 940      * the set to adapt. 941      * 942      * @return an adaption of a set to a set of 943      * primitive boolean values. 944      * 945      * @since 1.2 946      */ 947     public static BooleanSortedSet asBooleans(SortedSet set) 948     { return new SortedSetToBooleanSortedSetAdapter(set); } 949 950     /** 951      * Returns an adaption of a sorted set to a sorted set of 952      * primitive char values. 953      * 954      * @param set 955      * the set to adapt. 956      * 957      * @return an adaption of a set to a set of 958      * primitive char values. 959      * 960      * @since 1.2 961      */ 962     public static CharSortedSet asChars(SortedSet set) 963     { return new SortedSetToCharSortedSetAdapter(set); } 964 965     /** 966      * Returns an adaption of a sorted set to a sorted set of 967      * primitive byte values. 968      * 969      * @param set 970      * the set to adapt. 971      * 972      * @return an adaption of a set to a set of 973      * primitive byte values. 974      * 975      * @since 1.2 976      */ 977     public static ByteSortedSet asBytes(SortedSet set) 978     { return new SortedSetToByteSortedSetAdapter(set); } 979 980     /** 981      * Returns an adaption of a sorted set to a sorted set of 982      * primitive short values. 983      * 984      * @param set 985      * the set to adapt. 986      * 987      * @return an adaption of a set to a set of 988      * primitive short values. 989      * 990      * @since 1.2 991      */ 992     public static ShortSortedSet asShorts(SortedSet set) 993     { return new SortedSetToShortSortedSetAdapter(set); } 994 995     /** 996      * Returns an adaption of a sorted set to a sorted set of 997      * primitive int values. 998      * 999      * @param set 1000     * the set to adapt. 1001     * 1002     * @return an adaption of a set to a set of 1003     * primitive int values. 1004     * 1005     * @since 1.2 1006     */ 1007    public static IntSortedSet asInts(SortedSet set) 1008    { return new SortedSetToIntSortedSetAdapter(set); } 1009 1010    /** 1011     * Returns an adaption of a sorted set to a sorted set of 1012     * primitive long values. 1013     * 1014     * @param set 1015     * the set to adapt. 1016     * 1017     * @return an adaption of a set to a set of 1018     * primitive long values. 1019     * 1020     * @since 1.2 1021     */ 1022    public static LongSortedSet asLongs(SortedSet set) 1023    { return new SortedSetToLongSortedSetAdapter(set); } 1024 1025    /** 1026     * Returns an adaption of a sorted set to a sorted set of 1027     * primitive float values. 1028     * 1029     * @param set 1030     * the set to adapt. 1031     * 1032     * @return an adaption of a set to a set of 1033     * primitive float values. 1034     * 1035     * @since 1.2 1036     */ 1037    public static FloatSortedSet asFloats(SortedSet set) 1038    { return new SortedSetToFloatSortedSetAdapter(set); } 1039 1040    /** 1041     * Returns an adaption of a sorted set to a sorted set of 1042     * primitive double values. 1043     * 1044     * @param set 1045     * the set to adapt. 1046     * 1047     * @return an adaption of a set to a set of 1048     * primitive double values. 1049     * 1050     * @since 1.2 1051     */ 1052    public static DoubleSortedSet asDoubles(SortedSet set) 1053    { return new SortedSetToDoubleSortedSetAdapter(set); } 1054 1055    // --------------------------------------------------------------- 1056 // TSortedSet -> SortedSet 1057 // --------------------------------------------------------------- 1058 1059    /** 1060     * Returns an adaption of a sorted set of primitive boolean values 1061     * to a sorted set. 1062     * 1063     * @param set 1064     * the set to adapt. 1065     * 1066     * @return an adaption of a set of primitive boolean values 1067     * to a set. 1068     * 1069     * @since 1.2 1070     */ 1071    public static SortedSet asObjects(BooleanSortedSet set) 1072    { return new BooleanSortedSetToSortedSetAdapter(set); } 1073 1074    /** 1075     * Returns an adaption of a sorted set of primitive char values 1076     * to a sorted set. 1077     * 1078     * @param set 1079     * the set to adapt. 1080     * 1081     * @return an adaption of a set of primitive char values 1082     * to a set. 1083     * 1084     * @since 1.2 1085     */ 1086    public static SortedSet asObjects(CharSortedSet set) 1087    { return new CharSortedSetToSortedSetAdapter(set); } 1088 1089    /** 1090     * Returns an adaption of a sorted set of primitive byte values 1091     * to a sorted set. 1092     * 1093     * @param set 1094     * the set to adapt. 1095     * 1096     * @return an adaption of a set of primitive byte values 1097     * to a set. 1098     * 1099     * @since 1.2 1100     */ 1101    public static SortedSet asObjects(ByteSortedSet set) 1102    { return new ByteSortedSetToSortedSetAdapter(set); } 1103 1104    /** 1105     * Returns an adaption of a sorted set of primitive short values 1106     * to a sorted set. 1107     * 1108     * @param set 1109     * the set to adapt. 1110     * 1111     * @return an adaption of a set of primitive short values 1112     * to a set. 1113     * 1114     * @since 1.2 1115     */ 1116    public static SortedSet asObjects(ShortSortedSet set) 1117    { return new ShortSortedSetToSortedSetAdapter(set); } 1118 1119    /** 1120     * Returns an adaption of a sorted set of primitive int values 1121     * to a sorted set. 1122     * 1123     * @param set 1124     * the set to adapt. 1125     * 1126     * @return an adaption of a set of primitive int values 1127     * to a set. 1128     * 1129     * @since 1.2 1130     */ 1131    public static SortedSet asObjects(IntSortedSet set) 1132    { return new IntSortedSetToSortedSetAdapter(set); } 1133 1134    /** 1135     * Returns an adaption of a sorted set of primitive long values 1136     * to a sorted set. 1137     * 1138     * @param set 1139     * the set to adapt. 1140     * 1141     * @return an adaption of a set of primitive long values 1142     * to a set. 1143     * 1144     * @since 1.2 1145     */ 1146    public static SortedSet asObjects(LongSortedSet set) 1147    { return new LongSortedSetToSortedSetAdapter(set); } 1148 1149    /** 1150     * Returns an adaption of a sorted set of primitive float values 1151     * to a sorted set. 1152     * 1153     * @param set 1154     * the set to adapt. 1155     * 1156     * @return an adaption of a set of primitive float values 1157     * to a set. 1158     * 1159     * @since 1.2 1160     */ 1161    public static SortedSet asObjects(FloatSortedSet set) 1162    { return new FloatSortedSetToSortedSetAdapter(set); } 1163 1164    /** 1165     * Returns an adaption of a sorted set of primitive double values 1166     * to a sorted set. 1167     * 1168     * @param set 1169     * the set to adapt. 1170     * 1171     * @return an adaption of a set of primitive double values 1172     * to a set. 1173     * 1174     * @since 1.2 1175     */ 1176    public static SortedSet asObjects(DoubleSortedSet set) 1177    { return new DoubleSortedSetToSortedSetAdapter(set); } 1178 1179    // --------------------------------------------------------------- 1180 // List -> TList 1181 // --------------------------------------------------------------- 1182 1183    /** 1184     * Returns an adaption of a list to a list of 1185     * primitive boolean values. 1186     * 1187     * @param list 1188     * the list to adapt. 1189     * 1190     * @return an adaption of a list to a list of 1191     * primitive boolean values. 1192     */ 1193    public static BooleanList asBooleans(List list) 1194    { return new ListToBooleanListAdapter(list); } 1195 1196    /** 1197     * Returns an adaption of a list to a list of 1198     * primitive char values. 1199     * 1200     * @param list 1201     * the list to adapt. 1202     * 1203     * @return an adaption of a list to a list of 1204     * primitive char values. 1205     */ 1206    public static CharList asChars(List list) 1207    { return new ListToCharListAdapter(list); } 1208 1209    /** 1210     * Returns an adaption of a list to a list of 1211     * primitive byte values. 1212     * 1213     * @param list 1214     * the list to adapt. 1215     * 1216     * @return an adaption of a list to a list of 1217     * primitive byte values. 1218     */ 1219    public static ByteList asBytes(List list) 1220    { return new ListToByteListAdapter(list); } 1221 1222    /** 1223     * Returns an adaption of a list to a list of 1224     * primitive short values. 1225     * 1226     * @param list 1227     * the list to adapt. 1228     * 1229     * @return an adaption of a list to a list of 1230     * primitive short values. 1231     */ 1232    public static ShortList asShorts(List list) 1233    { return new ListToShortListAdapter(list); } 1234 1235    /** 1236     * Returns an adaption of a list to a list of 1237     * primitive int values. 1238     * 1239     * @param list 1240     * the list to adapt. 1241     * 1242     * @return an adaption of a list to a list of 1243     * primitive int values. 1244     */ 1245    public static IntList asInts(List list) 1246    { return new ListToIntListAdapter(list); } 1247 1248    /** 1249     * Returns an adaption of a list to a list of 1250     * primitive long values. 1251     * 1252     * @param list 1253     * the list to adapt. 1254     * 1255     * @return an adaption of a list to a list of 1256     * primitive long values. 1257     */ 1258    public static LongList asLongs(List list) 1259    { return new ListToLongListAdapter(list); } 1260 1261    /** 1262     * Returns an adaption of a list to a list of 1263     * primitive float values. 1264     * 1265     * @param list 1266     * the list to adapt. 1267     * 1268     * @return an adaption of a list to a list of 1269     * primitive float values. 1270     */ 1271    public static FloatList asFloats(List list) 1272    { return new ListToFloatListAdapter(list); } 1273 1274    /** 1275     * Returns an adaption of a list to a list of 1276     * primitive double values. 1277     * 1278     * @param list 1279     * the list to adapt. 1280     * 1281     * @return an adaption of a list to a list of 1282     * primitive double values. 1283     */ 1284    public static DoubleList asDoubles(List list) 1285    { return new ListToDoubleListAdapter(list); } 1286 1287    // --------------------------------------------------------------- 1288 // TList -> List 1289 // --------------------------------------------------------------- 1290 1291    /** 1292     * Returns an adaption of a list of primitive boolean values 1293     * to a list. 1294     * 1295     * @param list 1296     * the list to adapt. 1297     * 1298     * @return an adaption of a list of primitive boolean values 1299     * to a list. 1300     */ 1301    public static List asObjects(BooleanList list) 1302    { return new BooleanListToListAdapter(list); } 1303 1304    /** 1305     * Returns an adaption of a list of primitive char values 1306     * to a list. 1307     * 1308     * @param list 1309     * the list to adapt. 1310     * 1311     * @return an adaption of a list of primitive char values 1312     * to a list. 1313     */ 1314    public static List asObjects(CharList list) 1315    { return new CharListToListAdapter(list); } 1316 1317    /** 1318     * Returns an adaption of a list of primitive byte values 1319     * to a list. 1320     * 1321     * @param list 1322     * the list to adapt. 1323     * 1324     * @return an adaption of a list of primitive byte values 1325     * to a list. 1326     */ 1327    public static List asObjects(ByteList list) 1328    { return new ByteListToListAdapter(list); } 1329 1330    /** 1331     * Returns an adaption of a list of primitive short values 1332     * to a list. 1333     * 1334     * @param list 1335     * the list to adapt. 1336     * 1337     * @return an adaption of a list of primitive short values 1338     * to a list. 1339     */ 1340    public static List asObjects(ShortList list) 1341    { return new ShortListToListAdapter(list); } 1342 1343    /** 1344     * Returns an adaption of a list of primitive int values 1345     * to a list. 1346     * 1347     * @param list 1348     * the list to adapt. 1349     * 1350     * @return an adaption of a list of primitive int values 1351     * to a list. 1352     */ 1353    public static List asObjects(IntList list) 1354    { return new IntListToListAdapter(list); } 1355 1356    /** 1357     * Returns an adaption of a list of primitive long values 1358     * to a list. 1359     * 1360     * @param list 1361     * the list to adapt. 1362     * 1363     * @return an adaption of a list of primitive long values 1364     * to a list. 1365     */ 1366    public static List asObjects(LongList list) 1367    { return new LongListToListAdapter(list); } 1368 1369    /** 1370     * Returns an adaption of a list of primitive float values 1371     * to a list. 1372     * 1373     * @param list 1374     * the list to adapt. 1375     * 1376     * @return an adaption of a list of primitive float values 1377     * to a list. 1378     */ 1379    public static List asObjects(FloatList list) 1380    { return new FloatListToListAdapter(list); } 1381 1382    /** 1383     * Returns an adaption of a list of primitive double values 1384     * to a list. 1385     * 1386     * @param list 1387     * the list to adapt. 1388     * 1389     * @return an adaption of a list of primitive double values 1390     * to a list. 1391     */ 1392    public static List asObjects(DoubleList list) 1393    { return new DoubleListToListAdapter(list); } 1394 1395    // --------------------------------------------------------------- 1396 // Map -> TKeySMap 1397 // --------------------------------------------------------------- 1398 1399    /** 1400     * Returns an adaption of a map to a primitive map from 1401     * boolean keys to boolean values. 1402     * 1403     * @param map 1404     * the map to adapt. 1405     * 1406     * @return an adaption of a map to a primitive map from 1407     * boolean keys to boolean values. 1408     */ 1409    public static BooleanKeyBooleanMap asBooleanKeyBooleans(Map map) 1410    { return new MapToBooleanKeyBooleanMapAdapter(map); } 1411 1412    /** 1413     * Returns an adaption of a map to a primitive map from 1414     * boolean keys to char values. 1415     * 1416     * @param map 1417     * the map to adapt. 1418     * 1419     * @return an adaption of a map to a primitive map from 1420     * boolean keys to char values. 1421     */ 1422    public static BooleanKeyCharMap asBooleanKeyChars(Map map) 1423    { return new MapToBooleanKeyCharMapAdapter(map); } 1424 1425    /** 1426     * Returns an adaption of a map to a primitive map from 1427     * boolean keys to byte values. 1428     * 1429     * @param map 1430     * the map to adapt. 1431     * 1432     * @return an adaption of a map to a primitive map from 1433     * boolean keys to byte values. 1434     */ 1435    public static BooleanKeyByteMap asBooleanKeyBytes(Map map) 1436    { return new MapToBooleanKeyByteMapAdapter(map); } 1437 1438    /** 1439     * Returns an adaption of a map to a primitive map from 1440     * boolean keys to short values. 1441     * 1442     * @param map 1443     * the map to adapt. 1444     * 1445     * @return an adaption of a map to a primitive map from 1446     * boolean keys to short values. 1447     */ 1448    public static BooleanKeyShortMap asBooleanKeyShorts(Map map) 1449    { return new MapToBooleanKeyShortMapAdapter(map); } 1450 1451    /** 1452     * Returns an adaption of a map to a primitive map from 1453     * boolean keys to int values. 1454     * 1455     * @param map 1456     * the map to adapt. 1457     * 1458     * @return an adaption of a map to a primitive map from 1459     * boolean keys to int values. 1460     */ 1461    public static BooleanKeyIntMap asBooleanKeyInts(Map map) 1462    { return new MapToBooleanKeyIntMapAdapter(map); } 1463 1464    /** 1465     * Returns an adaption of a map to a primitive map from 1466     * boolean keys to long values. 1467     * 1468     * @param map 1469     * the map to adapt. 1470     * 1471     * @return an adaption of a map to a primitive map from 1472     * boolean keys to long values. 1473     */ 1474    public static BooleanKeyLongMap asBooleanKeyLongs(Map map) 1475    { return new MapToBooleanKeyLongMapAdapter(map); } 1476 1477    /** 1478     * Returns an adaption of a map to a primitive map from 1479     * boolean keys to float values. 1480     * 1481     * @param map 1482     * the map to adapt. 1483     * 1484     * @return an adaption of a map to a primitive map from 1485     * boolean keys to float values. 1486     */ 1487    public static BooleanKeyFloatMap asBooleanKeyFloats(Map map) 1488    { return new MapToBooleanKeyFloatMapAdapter(map); } 1489 1490    /** 1491     * Returns an adaption of a map to a primitive map from 1492     * boolean keys to double values. 1493     * 1494     * @param map 1495     * the map to adapt. 1496     * 1497     * @return an adaption of a map to a primitive map from 1498     * boolean keys to double values. 1499     */ 1500    public static BooleanKeyDoubleMap asBooleanKeyDoubles(Map map) 1501    { return new MapToBooleanKeyDoubleMapAdapter(map); } 1502 1503    /** 1504     * Returns an adaption of a map to a primitive map from 1505     * char keys to boolean values. 1506     * 1507     * @param map 1508     * the map to adapt. 1509     * 1510     * @return an adaption of a map to a primitive map from 1511     * char keys to boolean values. 1512     */ 1513    public static CharKeyBooleanMap asCharKeyBooleans(Map map) 1514    { return new MapToCharKeyBooleanMapAdapter(map); } 1515 1516    /** 1517     * Returns an adaption of a map to a primitive map from 1518     * char keys to char values. 1519     * 1520     * @param map 1521     * the map to adapt. 1522     * 1523     * @return an adaption of a map to a primitive map from 1524     * char keys to char values. 1525     */ 1526    public static CharKeyCharMap asCharKeyChars(Map map) 1527    { return new MapToCharKeyCharMapAdapter(map); } 1528 1529    /** 1530     * Returns an adaption of a map to a primitive map from 1531     * char keys to byte values. 1532     * 1533     * @param map 1534     * the map to adapt. 1535     * 1536     * @return an adaption of a map to a primitive map from 1537     * char keys to byte values. 1538     */ 1539    public static CharKeyByteMap asCharKeyBytes(Map map) 1540    { return new MapToCharKeyByteMapAdapter(map); } 1541 1542    /** 1543     * Returns an adaption of a map to a primitive map from 1544     * char keys to short values. 1545     * 1546     * @param map 1547     * the map to adapt. 1548     * 1549     * @return an adaption of a map to a primitive map from 1550     * char keys to short values. 1551     */ 1552    public static CharKeyShortMap asCharKeyShorts(Map map) 1553    { return new MapToCharKeyShortMapAdapter(map); } 1554 1555    /** 1556     * Returns an adaption of a map to a primitive map from 1557     * char keys to int values. 1558     * 1559     * @param map 1560     * the map to adapt. 1561     * 1562     * @return an adaption of a map to a primitive map from 1563     * char keys to int values. 1564     */ 1565    public static CharKeyIntMap asCharKeyInts(Map map) 1566    { return new MapToCharKeyIntMapAdapter(map); } 1567 1568    /** 1569     * Returns an adaption of a map to a primitive map from 1570     * char keys to long values. 1571     * 1572     * @param map 1573     * the map to adapt. 1574     * 1575     * @return an adaption of a map to a primitive map from 1576     * char keys to long values. 1577     */ 1578    public static CharKeyLongMap asCharKeyLongs(Map map) 1579    { return new MapToCharKeyLongMapAdapter(map); } 1580 1581    /** 1582     * Returns an adaption of a map to a primitive map from 1583     * char keys to float values. 1584     * 1585     * @param map 1586     * the map to adapt. 1587     * 1588     * @return an adaption of a map to a primitive map from 1589     * char keys to float values. 1590     */ 1591    public static CharKeyFloatMap asCharKeyFloats(Map map) 1592    { return new MapToCharKeyFloatMapAdapter(map); } 1593 1594    /** 1595     * Returns an adaption of a map to a primitive map from 1596     * char keys to double values. 1597     * 1598     * @param map 1599     * the map to adapt. 1600     * 1601     * @return an adaption of a map to a primitive map from 1602     * char keys to double values. 1603     */ 1604    public static CharKeyDoubleMap asCharKeyDoubles(Map map) 1605    { return new MapToCharKeyDoubleMapAdapter(map); } 1606 1607    /** 1608     * Returns an adaption of a map to a primitive map from 1609     * byte keys to boolean values. 1610     * 1611     * @param map 1612     * the map to adapt. 1613     * 1614     * @return an adaption of a map to a primitive map from 1615     * byte keys to boolean values. 1616     */ 1617    public static ByteKeyBooleanMap asByteKeyBooleans(Map map) 1618    { return new MapToByteKeyBooleanMapAdapter(map); } 1619 1620    /** 1621     * Returns an adaption of a map to a primitive map from 1622     * byte keys to char values. 1623     * 1624     * @param map 1625     * the map to adapt. 1626     * 1627     * @return an adaption of a map to a primitive map from 1628     * byte keys to char values. 1629     */ 1630    public static ByteKeyCharMap asByteKeyChars(Map map) 1631    { return new MapToByteKeyCharMapAdapter(map); } 1632 1633    /** 1634     * Returns an adaption of a map to a primitive map from 1635     * byte keys to byte values. 1636     * 1637     * @param map 1638     * the map to adapt. 1639     * 1640     * @return an adaption of a map to a primitive map from 1641     * byte keys to byte values. 1642     */ 1643    public static ByteKeyByteMap asByteKeyBytes(Map map) 1644    { return new MapToByteKeyByteMapAdapter(map); } 1645 1646    /** 1647     * Returns an adaption of a map to a primitive map from 1648     * byte keys to short values. 1649     * 1650     * @param map 1651     * the map to adapt. 1652     * 1653     * @return an adaption of a map to a primitive map from 1654     * byte keys to short values. 1655     */ 1656    public static ByteKeyShortMap asByteKeyShorts(Map map) 1657    { return new MapToByteKeyShortMapAdapter(map); } 1658 1659    /** 1660     * Returns an adaption of a map to a primitive map from 1661     * byte keys to int values. 1662     * 1663     * @param map 1664     * the map to adapt. 1665     * 1666     * @return an adaption of a map to a primitive map from 1667     * byte keys to int values. 1668     */ 1669    public static ByteKeyIntMap asByteKeyInts(Map map) 1670    { return new MapToByteKeyIntMapAdapter(map); } 1671 1672    /** 1673     * Returns an adaption of a map to a primitive map from 1674     * byte keys to long values. 1675     * 1676     * @param map 1677     * the map to adapt. 1678     * 1679     * @return an adaption of a map to a primitive map from 1680     * byte keys to long values. 1681     */ 1682    public static ByteKeyLongMap asByteKeyLongs(Map map) 1683    { return new MapToByteKeyLongMapAdapter(map); } 1684 1685    /** 1686     * Returns an adaption of a map to a primitive map from 1687     * byte keys to float values. 1688     * 1689     * @param map 1690     * the map to adapt. 1691     * 1692     * @return an adaption of a map to a primitive map from 1693     * byte keys to float values. 1694     */ 1695    public static ByteKeyFloatMap asByteKeyFloats(Map map) 1696    { return new MapToByteKeyFloatMapAdapter(map); } 1697 1698    /** 1699     * Returns an adaption of a map to a primitive map from 1700     * byte keys to double values. 1701     * 1702     * @param map 1703     * the map to adapt. 1704     * 1705     * @return an adaption of a map to a primitive map from 1706     * byte keys to double values. 1707     */ 1708    public static ByteKeyDoubleMap asByteKeyDoubles(Map map) 1709    { return new MapToByteKeyDoubleMapAdapter(map); } 1710 1711    /** 1712     * Returns an adaption of a map to a primitive map from 1713     * short keys to boolean values. 1714     * 1715     * @param map 1716     * the map to adapt. 1717     * 1718     * @return an adaption of a map to a primitive map from 1719     * short keys to boolean values. 1720     */ 1721    public static ShortKeyBooleanMap asShortKeyBooleans(Map map) 1722    { return new MapToShortKeyBooleanMapAdapter(map); } 1723 1724    /** 1725     * Returns an adaption of a map to a primitive map from 1726     * short keys to char values. 1727     * 1728     * @param map 1729     * the map to adapt. 1730     * 1731     * @return an adaption of a map to a primitive map from 1732     * short keys to char values. 1733     */ 1734    public static ShortKeyCharMap asShortKeyChars(Map map) 1735    { return new MapToShortKeyCharMapAdapter(map); } 1736 1737    /** 1738     * Returns an adaption of a map to a primitive map from 1739     * short keys to byte values. 1740     * 1741     * @param map 1742     * the map to adapt. 1743     * 1744     * @return an adaption of a map to a primitive map from 1745     * short keys to byte values. 1746     */ 1747    public static ShortKeyByteMap asShortKeyBytes(Map map) 1748    { return new MapToShortKeyByteMapAdapter(map); } 1749 1750    /** 1751     * Returns an adaption of a map to a primitive map from 1752     * short keys to short values. 1753     * 1754     * @param map 1755     * the map to adapt. 1756     * 1757     * @return an adaption of a map to a primitive map from 1758     * short keys to short values. 1759     */ 1760    public static ShortKeyShortMap asShortKeyShorts(Map map) 1761    { return new MapToShortKeyShortMapAdapter(map); } 1762 1763    /** 1764     * Returns an adaption of a map to a primitive map from 1765     * short keys to int values. 1766     * 1767     * @param map 1768     * the map to adapt. 1769     * 1770     * @return an adaption of a map to a primitive map from 1771     * short keys to int values. 1772     */ 1773    public static ShortKeyIntMap asShortKeyInts(Map map) 1774    { return new MapToShortKeyIntMapAdapter(map); } 1775 1776    /** 1777     * Returns an adaption of a map to a primitive map from 1778     * short keys to long values. 1779     * 1780     * @param map 1781     * the map to adapt. 1782     * 1783     * @return an adaption of a map to a primitive map from 1784     * short keys to long values. 1785     */ 1786    public static ShortKeyLongMap asShortKeyLongs(Map map) 1787    { return new MapToShortKeyLongMapAdapter(map); } 1788 1789    /** 1790     * Returns an adaption of a map to a primitive map from 1791     * short keys to float values. 1792     * 1793     * @param map 1794     * the map to adapt. 1795     * 1796     * @return an adaption of a map to a primitive map from 1797     * short keys to float values. 1798     */ 1799    public static ShortKeyFloatMap asShortKeyFloats(Map map) 1800    { return new MapToShortKeyFloatMapAdapter(map); } 1801 1802    /** 1803     * Returns an adaption of a map to a primitive map from 1804     * short keys to double values. 1805     * 1806     * @param map 1807     * the map to adapt. 1808     * 1809     * @return an adaption of a map to a primitive map from 1810     * short keys to double values. 1811     */ 1812    public static ShortKeyDoubleMap asShortKeyDoubles(Map map) 1813    { return new MapToShortKeyDoubleMapAdapter(map); } 1814 1815    /** 1816     * Returns an adaption of a map to a primitive map from 1817     * int keys to boolean values. 1818     * 1819     * @param map 1820     * the map to adapt. 1821     * 1822     * @return an adaption of a map to a primitive map from 1823     * int keys to boolean values. 1824     */ 1825    public static IntKeyBooleanMap asIntKeyBooleans(Map map) 1826    { return new MapToIntKeyBooleanMapAdapter(map); } 1827 1828    /** 1829     * Returns an adaption of a map to a primitive map from 1830     * int keys to char values. 1831     * 1832     * @param map 1833     * the map to adapt. 1834     * 1835     * @return an adaption of a map to a primitive map from 1836     * int keys to char values. 1837     */ 1838    public static IntKeyCharMap asIntKeyChars(Map map) 1839    { return new MapToIntKeyCharMapAdapter(map); } 1840 1841    /** 1842     * Returns an adaption of a map to a primitive map from 1843     * int keys to byte values. 1844     * 1845     * @param map 1846     * the map to adapt. 1847     * 1848     * @return an adaption of a map to a primitive map from 1849     * int keys to byte values. 1850     */ 1851    public static IntKeyByteMap asIntKeyBytes(Map map) 1852    { return new MapToIntKeyByteMapAdapter(map); } 1853 1854    /** 1855     * Returns an adaption of a map to a primitive map from 1856     * int keys to short values. 1857     * 1858     * @param map 1859     * the map to adapt. 1860     * 1861     * @return an adaption of a map to a primitive map from 1862     * int keys to short values. 1863     */ 1864    public static IntKeyShortMap asIntKeyShorts(Map map) 1865    { return new MapToIntKeyShortMapAdapter(map); } 1866 1867    /** 1868     * Returns an adaption of a map to a primitive map from 1869     * int keys to int values. 1870     * 1871     * @param map 1872     * the map to adapt. 1873     * 1874     * @return an adaption of a map to a primitive map from 1875     * int keys to int values. 1876     */ 1877    public static IntKeyIntMap asIntKeyInts(Map map) 1878    { return new MapToIntKeyIntMapAdapter(map); } 1879 1880    /** 1881     * Returns an adaption of a map to a primitive map from 1882     * int keys to long values. 1883     * 1884     * @param map 1885     * the map to adapt. 1886     * 1887     * @return an adaption of a map to a primitive map from 1888     * int keys to long values. 1889     */ 1890    public static IntKeyLongMap asIntKeyLongs(Map map) 1891    { return new MapToIntKeyLongMapAdapter(map); } 1892 1893    /** 1894     * Returns an adaption of a map to a primitive map from 1895     * int keys to float values. 1896     * 1897     * @param map 1898     * the map to adapt. 1899     * 1900     * @return an adaption of a map to a primitive map from 1901     * int keys to float values. 1902     */ 1903    public static IntKeyFloatMap asIntKeyFloats(Map map) 1904    { return new MapToIntKeyFloatMapAdapter(map); } 1905 1906    /** 1907     * Returns an adaption of a map to a primitive map from 1908     * int keys to double values. 1909     * 1910     * @param map 1911     * the map to adapt. 1912     * 1913     * @return an adaption of a map to a primitive map from 1914     * int keys to double values. 1915     */ 1916    public static IntKeyDoubleMap asIntKeyDoubles(Map map) 1917    { return new MapToIntKeyDoubleMapAdapter(map); } 1918 1919    /** 1920     * Returns an adaption of a map to a primitive map from 1921     * long keys to boolean values. 1922     * 1923     * @param map 1924     * the map to adapt. 1925     * 1926     * @return an adaption of a map to a primitive map from 1927     * long keys to boolean values. 1928     */ 1929    public static LongKeyBooleanMap asLongKeyBooleans(Map map) 1930    { return new MapToLongKeyBooleanMapAdapter(map); } 1931 1932    /** 1933     * Returns an adaption of a map to a primitive map from 1934     * long keys to char values. 1935     * 1936     * @param map 1937     * the map to adapt. 1938     * 1939     * @return an adaption of a map to a primitive map from 1940     * long keys to char values. 1941     */ 1942    public static LongKeyCharMap asLongKeyChars(Map map) 1943    { return new MapToLongKeyCharMapAdapter(map); } 1944 1945    /** 1946     * Returns an adaption of a map to a primitive map from 1947     * long keys to byte values. 1948     * 1949     * @param map 1950     * the map to adapt. 1951     * 1952     * @return an adaption of a map to a primitive map from 1953     * long keys to byte values. 1954     */ 1955    public static LongKeyByteMap asLongKeyBytes(Map map) 1956    { return new MapToLongKeyByteMapAdapter(map); } 1957 1958    /** 1959     * Returns an adaption of a map to a primitive map from 1960     * long keys to short values. 1961     * 1962     * @param map 1963     * the map to adapt. 1964     * 1965     * @return an adaption of a map to a primitive map from 1966     * long keys to short values. 1967     */ 1968    public static LongKeyShortMap asLongKeyShorts(Map map) 1969    { return new MapToLongKeyShortMapAdapter(map); } 1970 1971    /** 1972     * Returns an adaption of a map to a primitive map from 1973     * long keys to int values. 1974     * 1975     * @param map 1976     * the map to adapt. 1977     * 1978     * @return an adaption of a map to a primitive map from 1979     * long keys to int values. 1980     */ 1981    public static LongKeyIntMap asLongKeyInts(Map map) 1982    { return new MapToLongKeyIntMapAdapter(map); } 1983 1984    /** 1985     * Returns an adaption of a map to a primitive map from 1986     * long keys to long values. 1987     * 1988     * @param map 1989     * the map to adapt. 1990     * 1991     * @return an adaption of a map to a primitive map from 1992     * long keys to long values. 1993     */ 1994    public static LongKeyLongMap asLongKeyLongs(Map map) 1995    { return new MapToLongKeyLongMapAdapter(map); } 1996 1997    /** 1998     * Returns an adaption of a map to a primitive map from 1999     * long keys to float values. 2000     * 2001     * @param map 2002     * the map to adapt. 2003     * 2004     * @return an adaption of a map to a primitive map from 2005     * long keys to float values. 2006     */ 2007    public static LongKeyFloatMap asLongKeyFloats(Map map) 2008    { return new MapToLongKeyFloatMapAdapter(map); } 2009 2010    /** 2011     * Returns an adaption of a map to a primitive map from 2012     * long keys to double values. 2013     * 2014     * @param map 2015     * the map to adapt. 2016     * 2017     * @return an adaption of a map to a primitive map from 2018     * long keys to double values. 2019     */ 2020    public static LongKeyDoubleMap asLongKeyDoubles(Map map) 2021    { return new MapToLongKeyDoubleMapAdapter(map); } 2022 2023    /** 2024     * Returns an adaption of a map to a primitive map from 2025     * float keys to boolean values. 2026     * 2027     * @param map 2028     * the map to adapt. 2029     * 2030     * @return an adaption of a map to a primitive map from 2031     * float keys to boolean values. 2032     */ 2033    public static FloatKeyBooleanMap asFloatKeyBooleans(Map map) 2034    { return new MapToFloatKeyBooleanMapAdapter(map); } 2035 2036    /** 2037     * Returns an adaption of a map to a primitive map from 2038     * float keys to char values. 2039     * 2040     * @param map 2041     * the map to adapt. 2042     * 2043     * @return an adaption of a map to a primitive map from 2044     * float keys to char values. 2045     */ 2046    public static FloatKeyCharMap asFloatKeyChars(Map map) 2047    { return new MapToFloatKeyCharMapAdapter(map); } 2048 2049    /** 2050     * Returns an adaption of a map to a primitive map from 2051     * float keys to byte values. 2052     * 2053     * @param map 2054     * the map to adapt. 2055     * 2056     * @return an adaption of a map to a primitive map from 2057     * float keys to byte values. 2058     */ 2059    public static FloatKeyByteMap asFloatKeyBytes(Map map) 2060    { return new MapToFloatKeyByteMapAdapter(map); } 2061 2062    /** 2063     * Returns an adaption of a map to a primitive map from 2064     * float keys to short values. 2065     * 2066     * @param map 2067     * the map to adapt. 2068     * 2069     * @return an adaption of a map to a primitive map from 2070     * float keys to short values. 2071     */ 2072    public static FloatKeyShortMap asFloatKeyShorts(Map map) 2073    { return new MapToFloatKeyShortMapAdapter(map); } 2074 2075    /** 2076     * Returns an adaption of a map to a primitive map from 2077     * float keys to int values. 2078     * 2079     * @param map 2080     * the map to adapt. 2081     * 2082     * @return an adaption of a map to a primitive map from 2083     * float keys to int values. 2084     */ 2085    public static FloatKeyIntMap asFloatKeyInts(Map map) 2086    { return new MapToFloatKeyIntMapAdapter(map); } 2087 2088    /** 2089     * Returns an adaption of a map to a primitive map from 2090     * float keys to long values. 2091     * 2092     * @param map 2093     * the map to adapt. 2094     * 2095     * @return an adaption of a map to a primitive map from 2096     * float keys to long values. 2097     */ 2098    public static FloatKeyLongMap asFloatKeyLongs(Map map) 2099    { return new MapToFloatKeyLongMapAdapter(map); } 2100 2101    /** 2102     * Returns an adaption of a map to a primitive map from 2103     * float keys to float values. 2104     * 2105     * @param map 2106     * the map to adapt. 2107     * 2108     * @return an adaption of a map to a primitive map from 2109     * float keys to float values. 2110     */ 2111    public static FloatKeyFloatMap asFloatKeyFloats(Map map) 2112    { return new MapToFloatKeyFloatMapAdapter(map); } 2113 2114    /** 2115     * Returns an adaption of a map to a primitive map from 2116     * float keys to double values. 2117     * 2118     * @param map 2119     * the map to adapt. 2120     * 2121     * @return an adaption of a map to a primitive map from 2122     * float keys to double values. 2123     */ 2124    public static FloatKeyDoubleMap asFloatKeyDoubles(Map map) 2125    { return new MapToFloatKeyDoubleMapAdapter(map); } 2126 2127    /** 2128     * Returns an adaption of a map to a primitive map from 2129     * double keys to boolean values. 2130     * 2131     * @param map 2132     * the map to adapt. 2133     * 2134     * @return an adaption of a map to a primitive map from 2135     * double keys to boolean values. 2136     */ 2137    public static DoubleKeyBooleanMap asDoubleKeyBooleans(Map map) 2138    { return new MapToDoubleKeyBooleanMapAdapter(map); } 2139 2140    /** 2141     * Returns an adaption of a map to a primitive map from 2142     * double keys to char values. 2143     * 2144     * @param map 2145     * the map to adapt. 2146     * 2147     * @return an adaption of a map to a primitive map from 2148     * double keys to char values. 2149     */ 2150    public static DoubleKeyCharMap asDoubleKeyChars(Map map) 2151    { return new MapToDoubleKeyCharMapAdapter(map); } 2152 2153    /** 2154     * Returns an adaption of a map to a primitive map from 2155     * double keys to byte values. 2156     * 2157     * @param map 2158     * the map to adapt. 2159     * 2160     * @return an adaption of a map to a primitive map from 2161     * double keys to byte values. 2162     */ 2163    public static DoubleKeyByteMap asDoubleKeyBytes(Map map) 2164    { return new MapToDoubleKeyByteMapAdapter(map); } 2165 2166    /** 2167     * Returns an adaption of a map to a primitive map from 2168     * double keys to short values. 2169     * 2170     * @param map 2171     * the map to adapt. 2172     * 2173     * @return an adaption of a map to a primitive map from 2174     * double keys to short values. 2175     */ 2176    public static DoubleKeyShortMap asDoubleKeyShorts(Map map) 2177    { return new MapToDoubleKeyShortMapAdapter(map); } 2178 2179    /** 2180     * Returns an adaption of a map to a primitive map from 2181     * double keys to int values. 2182     * 2183     * @param map 2184     * the map to adapt. 2185     * 2186     * @return an adaption of a map to a primitive map from 2187     * double keys to int values. 2188     */ 2189    public static DoubleKeyIntMap asDoubleKeyInts(Map map) 2190    { return new MapToDoubleKeyIntMapAdapter(map); } 2191 2192    /** 2193     * Returns an adaption of a map to a primitive map from 2194     * double keys to long values. 2195     * 2196     * @param map 2197     * the map to adapt. 2198     * 2199     * @return an adaption of a map to a primitive map from 2200     * double keys to long values. 2201     */ 2202    public static DoubleKeyLongMap asDoubleKeyLongs(Map map) 2203    { return new MapToDoubleKeyLongMapAdapter(map); } 2204 2205    /** 2206     * Returns an adaption of a map to a primitive map from 2207     * double keys to float values. 2208     * 2209     * @param map 2210     * the map to adapt. 2211     * 2212     * @return an adaption of a map to a primitive map from 2213     * double keys to float values. 2214     */ 2215    public static DoubleKeyFloatMap asDoubleKeyFloats(Map map) 2216    { return new MapToDoubleKeyFloatMapAdapter(map); } 2217 2218    /** 2219     * Returns an adaption of a map to a primitive map from 2220     * double keys to double values. 2221     * 2222     * @param map 2223     * the map to adapt. 2224     * 2225     * @return an adaption of a map to a primitive map from 2226     * double keys to double values. 2227     */ 2228    public static DoubleKeyDoubleMap asDoubleKeyDoubles(Map map) 2229    { return new MapToDoubleKeyDoubleMapAdapter(map); } 2230 2231    // --------------------------------------------------------------- 2232 // TKeySMap -> Map 2233 // --------------------------------------------------------------- 2234 2235    /** 2236     * Returns an adaption of a primitive map from 2237     * boolean keys to boolean values to a map. 2238     * 2239     * @param map 2240     * the primitive map to adapt. 2241     * 2242     * @return an adaption of the specified primitive 2243     * map to a map. 2244     */ 2245    public static Map asObjects(BooleanKeyBooleanMap map) 2246    { return new BooleanKeyBooleanMapToMapAdapter(map); } 2247 2248    /** 2249     * Returns an adaption of a primitive map from 2250     * boolean keys to byte values to a map. 2251     * 2252     * @param map 2253     * the primitive map to adapt. 2254     * 2255     * @return an adaption of the specified primitive 2256     * map to a map. 2257     */ 2258    public static Map asObjects(BooleanKeyByteMap map) 2259    { return new BooleanKeyByteMapToMapAdapter(map); } 2260 2261    /** 2262     * Returns an adaption of a primitive map from 2263     * boolean keys to short values to a map. 2264     * 2265     * @param map 2266     * the primitive map to adapt. 2267     * 2268     * @return an adaption of the specified primitive 2269     * map to a map. 2270     */ 2271    public static Map asObjects(BooleanKeyShortMap map) 2272    { return new BooleanKeyShortMapToMapAdapter(map); } 2273 2274    /** 2275     * Returns an adaption of a primitive map from 2276     * boolean keys to int values to a map. 2277     * 2278     * @param map 2279     * the primitive map to adapt. 2280     * 2281     * @return an adaption of the specified primitive 2282     * map to a map. 2283     */ 2284    public static Map asObjects(BooleanKeyIntMap map) 2285    { return new BooleanKeyIntMapToMapAdapter(map); } 2286 2287    /** 2288     * Returns an adaption of a primitive map from 2289     * boolean keys to long values to a map. 2290     * 2291     * @param map 2292     * the primitive map to adapt. 2293     * 2294     * @return an adaption of the specified primitive 2295     * map to a map. 2296     */ 2297    public static Map asObjects(BooleanKeyLongMap map) 2298    { return new BooleanKeyLongMapToMapAdapter(map); } 2299 2300    /** 2301     * Returns an adaption of a primitive map from 2302     * boolean keys to float values to a map. 2303     * 2304     * @param map 2305     * the primitive map to adapt. 2306     * 2307     * @return an adaption of the specified primitive 2308     * map to a map. 2309     */ 2310    public static Map asObjects(BooleanKeyFloatMap map) 2311    { return new BooleanKeyFloatMapToMapAdapter(map); } 2312 2313    /** 2314     * Returns an adaption of a primitive map from 2315     * boolean keys to double values to a map. 2316     * 2317     * @param map 2318     * the primitive map to adapt. 2319     * 2320     * @return an adaption of the specified primitive 2321     * map to a map. 2322     */ 2323    public static Map asObjects(BooleanKeyDoubleMap map) 2324    { return new BooleanKeyDoubleMapToMapAdapter(map); } 2325 2326    /** 2327     * Returns an adaption of a primitive map from 2328     * char keys to boolean values to a map. 2329     * 2330     * @param map 2331     * the primitive map to adapt. 2332     * 2333     * @return an adaption of the specified primitive 2334     * map to a map. 2335     */ 2336    public static Map asObjects(CharKeyBooleanMap map) 2337    { return new CharKeyBooleanMapToMapAdapter(map); } 2338 2339    /** 2340     * Returns an adaption of a primitive map from 2341     * char keys to char values to a map. 2342     * 2343     * @param map 2344     * the primitive map to adapt. 2345     * 2346     * @return an adaption of the specified primitive 2347     * map to a map. 2348     */ 2349    public static Map asObjects(CharKeyCharMap map) 2350    { return new CharKeyCharMapToMapAdapter(map); } 2351 2352    /** 2353     * Returns an adaption of a primitive map from 2354     * char keys to byte values to a map. 2355     * 2356     * @param map 2357     * the primitive map to adapt. 2358     * 2359     * @return an adaption of the specified primitive 2360     * map to a map. 2361     */ 2362    public static Map asObjects(CharKeyByteMap map) 2363    { return new CharKeyByteMapToMapAdapter(map); } 2364 2365    /** 2366     * Returns an adaption of a primitive map from 2367     * char keys to short values to a map. 2368     * 2369     * @param map 2370     * the primitive map to adapt. 2371     * 2372     * @return an adaption of the specified primitive 2373     * map to a map. 2374     */ 2375    public static Map asObjects(CharKeyShortMap map) 2376    { return new CharKeyShortMapToMapAdapter(map); } 2377 2378    /** 2379     * Returns an adaption of a primitive map from 2380     * char keys to int values to a map. 2381     * 2382     * @param map 2383     * the primitive map to adapt. 2384     * 2385     * @return an adaption of the specified primitive 2386     * map to a map. 2387     */ 2388    public static Map asObjects(CharKeyIntMap map) 2389    { return new CharKeyIntMapToMapAdapter(map); } 2390 2391    /** 2392     * Returns an adaption of a primitive map from 2393     * char keys to long values to a map. 2394     * 2395     * @param map 2396     * the primitive map to adapt. 2397     * 2398     * @return an adaption of the specified primitive 2399     * map to a map. 2400     */ 2401    public static Map asObjects(CharKeyLongMap map) 2402    { return new CharKeyLongMapToMapAdapter(map); } 2403 2404    /** 2405     * Returns an adaption of a primitive map from 2406     * char keys to float values to a map. 2407     * 2408     * @param map 2409     * the primitive map to adapt. 2410     * 2411     * @return an adaption of the specified primitive 2412     * map to a map. 2413     */ 2414    public static Map asObjects(CharKeyFloatMap map) 2415    { return new CharKeyFloatMapToMapAdapter(map); } 2416 2417    /** 2418     * Returns an adaption of a primitive map from 2419     * char keys to double values to a map. 2420     * 2421     * @param map 2422     * the primitive map to adapt. 2423     * 2424     * @return an adaption of the specified primitive 2425     * map to a map. 2426     */ 2427    public static Map asObjects(CharKeyDoubleMap map) 2428    { return new CharKeyDoubleMapToMapAdapter(map); } 2429 2430    /** 2431     * Returns an adaption of a primitive map from 2432     * byte keys to boolean values to a map. 2433     * 2434     * @param map 2435     * the primitive map to adapt. 2436     * 2437     * @return an adaption of the specified primitive 2438     * map to a map. 2439     */ 2440    public static Map asObjects(ByteKeyBooleanMap map) 2441    { return new ByteKeyBooleanMapToMapAdapter(map); } 2442 2443    /** 2444     * Returns an adaption of a primitive map from 2445     * byte keys to char values to a map. 2446     * 2447     * @param map 2448     * the primitive map to adapt. 2449     * 2450     * @return an adaption of the specified primitive 2451     * map to a map. 2452     */ 2453    public static Map asObjects(ByteKeyCharMap map) 2454    { return new ByteKeyCharMapToMapAdapter(map); } 2455 2456    /** 2457     * Returns an adaption of a primitive map from 2458     * byte keys to byte values to a map. 2459     * 2460     * @param map 2461     * the primitive map to adapt. 2462     * 2463     * @return an adaption of the specified primitive 2464     * map to a map. 2465     */ 2466    public static Map asObjects(ByteKeyByteMap map) 2467    { return new ByteKeyByteMapToMapAdapter(map); } 2468 2469    /** 2470     * Returns an adaption of a primitive map from 2471     * byte keys to short values to a map. 2472     * 2473     * @param map 2474     * the primitive map to adapt. 2475     * 2476     * @return an adaption of the specified primitive 2477     * map to a map. 2478     */ 2479    public static Map asObjects(ByteKeyShortMap map) 2480    { return new ByteKeyShortMapToMapAdapter(map); } 2481 2482    /** 2483     * Returns an adaption of a primitive map from 2484     * byte keys to int values to a map. 2485     * 2486     * @param map 2487     * the primitive map to adapt. 2488     * 2489     * @return an adaption of the specified primitive 2490     * map to a map. 2491     */ 2492    public static Map asObjects(ByteKeyIntMap map) 2493    { return new ByteKeyIntMapToMapAdapter(map); } 2494 2495    /** 2496     * Returns an adaption of a primitive map from 2497     * byte keys to long values to a map. 2498     * 2499     * @param map 2500     * the primitive map to adapt. 2501     * 2502     * @return an adaption of the specified primitive 2503     * map to a map. 2504     */ 2505    public static Map asObjects(ByteKeyLongMap map) 2506    { return new ByteKeyLongMapToMapAdapter(map); } 2507 2508    /** 2509     * Returns an adaption of a primitive map from 2510     * byte keys to float values to a map. 2511     * 2512     * @param map 2513     * the primitive map to adapt. 2514     * 2515     * @return an adaption of the specified primitive 2516     * map to a map. 2517     */ 2518    public static Map asObjects(ByteKeyFloatMap map) 2519    { return new ByteKeyFloatMapToMapAdapter(map); } 2520 2521    /** 2522     * Returns an adaption of a primitive map from 2523     * byte keys to double values to a map. 2524     * 2525     * @param map 2526     * the primitive map to adapt. 2527     * 2528     * @return an adaption of the specified primitive 2529     * map to a map. 2530     */ 2531    public static Map asObjects(ByteKeyDoubleMap map) 2532    { return new ByteKeyDoubleMapToMapAdapter(map); } 2533 2534    /** 2535     * Returns an adaption of a primitive map from 2536     * short keys to boolean values to a map. 2537     * 2538     * @param map 2539     * the primitive map to adapt. 2540     * 2541     * @return an adaption of the specified primitive 2542     * map to a map. 2543     */ 2544    public static Map asObjects(ShortKeyBooleanMap map) 2545    { return new ShortKeyBooleanMapToMapAdapter(map); } 2546 2547    /** 2548     * Returns an adaption of a primitive map from 2549     * short keys to char values to a map. 2550     * 2551     * @param map 2552     * the primitive map to adapt. 2553     * 2554     * @return an adaption of the specified primitive 2555     * map to a map. 2556     */ 2557    public static Map asObjects(ShortKeyCharMap map) 2558    { return new ShortKeyCharMapToMapAdapter(map); } 2559 2560    /** 2561     * Returns an adaption of a primitive map from 2562     * short keys to byte values to a map. 2563     * 2564     * @param map 2565     * the primitive map to adapt. 2566     * 2567     * @return an adaption of the specified primitive 2568     * map to a map. 2569     */ 2570    public static Map asObjects(ShortKeyByteMap map) 2571    { return new ShortKeyByteMapToMapAdapter(map); } 2572 2573    /** 2574     * Returns an adaption of a primitive map from 2575     * short keys to short values to a map. 2576     * 2577     * @param map 2578     * the primitive map to adapt. 2579     * 2580     * @return an adaption of the specified primitive 2581     * map to a map. 2582     */ 2583    public static Map asObjects(ShortKeyShortMap map) 2584    { return new ShortKeyShortMapToMapAdapter(map); } 2585 2586    /** 2587     * Returns an adaption of a primitive map from 2588     * short keys to int values to a map. 2589     * 2590     * @param map 2591     * the primitive map to adapt. 2592     * 2593     * @return an adaption of the specified primitive 2594     * map to a map. 2595     */ 2596    public static Map asObjects(ShortKeyIntMap map) 2597    { return new ShortKeyIntMapToMapAdapter(map); } 2598 2599    /** 2600     * Returns an adaption of a primitive map from 2601     * short keys to long values to a map. 2602     * 2603     * @param map 2604     * the primitive map to adapt. 2605     * 2606     * @return an adaption of the specified primitive 2607     * map to a map. 2608     */ 2609    public static Map asObjects(ShortKeyLongMap map) 2610    { return new ShortKeyLongMapToMapAdapter(map); } 2611 2612    /** 2613     * Returns an adaption of a primitive map from 2614     * short keys to float values to a map. 2615     * 2616     * @param map 2617     * the primitive map to adapt. 2618     * 2619     * @return an adaption of the specified primitive 2620     * map to a map. 2621     */ 2622    public static Map asObjects(ShortKeyFloatMap map) 2623    { return new ShortKeyFloatMapToMapAdapter(map); } 2624 2625    /** 2626     * Returns an adaption of a primitive map from 2627     * short keys to double values to a map. 2628     * 2629     * @param map 2630     * the primitive map to adapt. 2631     * 2632     * @return an adaption of the specified primitive 2633     * map to a map. 2634     */ 2635    public static Map asObjects(ShortKeyDoubleMap map) 2636    { return new ShortKeyDoubleMapToMapAdapter(map); } 2637 2638    /** 2639     * Returns an adaption of a primitive map from 2640     * int keys to boolean values to a map. 2641     * 2642     * @param map 2643     * the primitive map to adapt. 2644     * 2645     * @return an adaption of the specified primitive 2646     * map to a map. 2647     */ 2648    public static Map asObjects(IntKeyBooleanMap map) 2649    { return new IntKeyBooleanMapToMapAdapter(map); } 2650 2651    /** 2652     * Returns an adaption of a primitive map from 2653     * int keys to char values to a map. 2654     * 2655     * @param map 2656     * the primitive map to adapt. 2657     * 2658     * @return an adaption of the specified primitive 2659     * map to a map. 2660     */ 2661    public static Map asObjects(IntKeyCharMap map) 2662    { return new IntKeyCharMapToMapAdapter(map); } 2663 2664    /** 2665     * Returns an adaption of a primitive map from 2666     * int keys to byte values to a map. 2667     * 2668     * @param map 2669     * the primitive map to adapt. 2670     * 2671     * @return an adaption of the specified primitive 2672     * map to a map. 2673     */ 2674    public static Map asObjects(IntKeyByteMap map) 2675    { return new IntKeyByteMapToMapAdapter(map); } 2676 2677    /** 2678     * Returns an adaption of a primitive map from 2679     * int keys to short values to a map. 2680     * 2681     * @param map 2682     * the primitive map to adapt. 2683     * 2684     * @return an adaption of the specified primitive 2685     * map to a map. 2686     */ 2687    public static Map asObjects(IntKeyShortMap map) 2688    { return new IntKeyShortMapToMapAdapter(map); } 2689 2690    /** 2691     * Returns an adaption of a primitive map from 2692     * int keys to int values to a map. 2693     * 2694     * @param map 2695     * the primitive map to adapt. 2696     * 2697     * @return an adaption of the specified primitive 2698     * map to a map. 2699     */ 2700    public static Map asObjects(IntKeyIntMap map) 2701    { return new IntKeyIntMapToMapAdapter(map); } 2702 2703    /** 2704     * Returns an adaption of a primitive map from 2705     * int keys to long values to a map. 2706     * 2707     * @param map 2708     * the primitive map to adapt. 2709     * 2710     * @return an adaption of the specified primitive 2711     * map to a map. 2712     */ 2713    public static Map asObjects(IntKeyLongMap map) 2714    { return new IntKeyLongMapToMapAdapter(map); } 2715 2716    /** 2717     * Returns an adaption of a primitive map from 2718     * int keys to float values to a map. 2719     * 2720     * @param map 2721     * the primitive map to adapt. 2722     * 2723     * @return an adaption of the specified primitive 2724     * map to a map. 2725     */ 2726    public static Map asObjects(IntKeyFloatMap map) 2727    { return new IntKeyFloatMapToMapAdapter(map); } 2728 2729    /** 2730     * Returns an adaption of a primitive map from 2731     * int keys to double values to a map. 2732     * 2733     * @param map 2734     * the primitive map to adapt. 2735     * 2736     * @return an adaption of the specified primitive 2737     * map to a map. 2738     */ 2739    public static Map asObjects(IntKeyDoubleMap map) 2740    { return new IntKeyDoubleMapToMapAdapter(map); } 2741 2742    /** 2743     * Returns an adaption of a primitive map from 2744     * long keys to boolean values to a map. 2745     * 2746     * @param map 2747     * the primitive map to adapt. 2748     * 2749     * @return an adaption of the specified primitive 2750     * map to a map. 2751     */ 2752    public static Map asObjects(LongKeyBooleanMap map) 2753    { return new LongKeyBooleanMapToMapAdapter(map); } 2754 2755    /** 2756     * Returns an adaption of a primitive map from 2757     * long keys to char values to a map. 2758     * 2759     * @param map 2760     * the primitive map to adapt. 2761     * 2762     * @return an adaption of the specified primitive 2763     * map to a map. 2764     */ 2765    public static Map asObjects(LongKeyCharMap map) 2766    { return new LongKeyCharMapToMapAdapter(map); } 2767 2768    /** 2769     * Returns an adaption of a primitive map from 2770     * long keys to byte values to a map. 2771     * 2772     * @param map 2773     * the primitive map to adapt. 2774     * 2775     * @return an adaption of the specified primitive 2776     * map to a map. 2777     */ 2778    public static Map asObjects(LongKeyByteMap map) 2779    { return new LongKeyByteMapToMapAdapter(map); } 2780 2781    /** 2782     * Returns an adaption of a primitive map from 2783     * long keys to short values to a map. 2784     * 2785     * @param map 2786     * the primitive map to adapt. 2787     * 2788     * @return an adaption of the specified primitive 2789     * map to a map. 2790     */ 2791    public static Map asObjects(LongKeyShortMap map) 2792    { return new LongKeyShortMapToMapAdapter(map); } 2793 2794    /** 2795     * Returns an adaption of a primitive map from 2796     * long keys to int values to a map. 2797     * 2798     * @param map 2799     * the primitive map to adapt. 2800     * 2801     * @return an adaption of the specified primitive 2802     * map to a map. 2803     */ 2804    public static Map asObjects(LongKeyIntMap map) 2805    { return new LongKeyIntMapToMapAdapter(map); } 2806 2807    /** 2808     * Returns an adaption of a primitive map from 2809     * long keys to long values to a map. 2810     * 2811     * @param map 2812     * the primitive map to adapt. 2813     * 2814     * @return an adaption of the specified primitive 2815     * map to a map. 2816     */ 2817    public static Map asObjects(LongKeyLongMap map) 2818    { return new LongKeyLongMapToMapAdapter(map); } 2819 2820    /** 2821     * Returns an adaption of a primitive map from 2822     * long keys to float values to a map. 2823     * 2824     * @param map 2825     * the primitive map to adapt. 2826     * 2827     * @return an adaption of the specified primitive 2828     * map to a map. 2829     */ 2830    public static Map asObjects(LongKeyFloatMap map) 2831    { return new LongKeyFloatMapToMapAdapter(map); } 2832 2833    /** 2834     * Returns an adaption of a primitive map from 2835     * long keys to double values to a map. 2836     * 2837     * @param map 2838     * the primitive map to adapt. 2839     * 2840     * @return an adaption of the specified primitive 2841     * map to a map. 2842     */ 2843    public static Map asObjects(LongKeyDoubleMap map) 2844    { return new LongKeyDoubleMapToMapAdapter(map); } 2845 2846    /** 2847     * Returns an adaption of a primitive map from 2848     * float keys to boolean values to a map. 2849     * 2850     * @param map 2851     * the primitive map to adapt. 2852     * 2853     * @return an adaption of the specified primitive 2854     * map to a map. 2855     */ 2856    public static Map asObjects(FloatKeyBooleanMap map) 2857    { return new FloatKeyBooleanMapToMapAdapter(map); } 2858 2859    /** 2860     * Returns an adaption of a primitive map from 2861     * float keys to char values to a map. 2862     * 2863     * @param map 2864     * the primitive map to adapt. 2865     * 2866     * @return an adaption of the specified primitive 2867     * map to a map. 2868     */ 2869    public static Map asObjects(FloatKeyCharMap map) 2870    { return new FloatKeyCharMapToMapAdapter(map); } 2871 2872    /** 2873     * Returns an adaption of a primitive map from 2874     * float keys to byte values to a map. 2875     * 2876     * @param map 2877     * the primitive map to adapt. 2878     * 2879     * @return an adaption of the specified primitive 2880     * map to a map. 2881     */ 2882    public static Map asObjects(FloatKeyByteMap map) 2883    { return new FloatKeyByteMapToMapAdapter(map); } 2884 2885    /** 2886     * Returns an adaption of a primitive map from 2887     * float keys to short values to a map. 2888     * 2889     * @param map 2890     * the primitive map to adapt. 2891     * 2892     * @return an adaption of the specified primitive 2893     * map to a map. 2894     */ 2895    public static Map asObjects(FloatKeyShortMap map) 2896    { return new FloatKeyShortMapToMapAdapter(map); } 2897 2898    /** 2899     * Returns an adaption of a primitive map from 2900     * float keys to int values to a map. 2901     * 2902     * @param map 2903     * the primitive map to adapt. 2904     * 2905     * @return an adaption of the specified primitive 2906     * map to a map. 2907     */ 2908    public static Map asObjects(FloatKeyIntMap map) 2909    { return new FloatKeyIntMapToMapAdapter(map); } 2910 2911    /** 2912     * Returns an adaption of a primitive map from 2913     * float keys to long values to a map. 2914     * 2915     * @param map 2916     * the primitive map to adapt. 2917     * 2918     * @return an adaption of the specified primitive 2919     * map to a map. 2920     */ 2921    public static Map asObjects(FloatKeyLongMap map) 2922    { return new FloatKeyLongMapToMapAdapter(map); } 2923 2924    /** 2925     * Returns an adaption of a primitive map from 2926     * float keys to float values to a map. 2927     * 2928     * @param map 2929     * the primitive map to adapt. 2930     * 2931     * @return an adaption of the specified primitive 2932     * map to a map. 2933     */ 2934    public static Map asObjects(FloatKeyFloatMap map) 2935    { return new FloatKeyFloatMapToMapAdapter(map); } 2936 2937    /** 2938     * Returns an adaption of a primitive map from 2939     * float keys to double values to a map. 2940     * 2941     * @param map 2942     * the primitive map to adapt. 2943     * 2944     * @return an adaption of the specified primitive 2945     * map to a map. 2946     */ 2947    public static Map asObjects(FloatKeyDoubleMap map) 2948    { return new FloatKeyDoubleMapToMapAdapter(map); } 2949 2950    /** 2951     * Returns an adaption of a primitive map from 2952     * double keys to boolean values to a map. 2953     * 2954     * @param map 2955     * the primitive map to adapt. 2956     * 2957     * @return an adaption of the specified primitive 2958     * map to a map. 2959     */ 2960    public static Map asObjects(DoubleKeyBooleanMap map) 2961    { return new DoubleKeyBooleanMapToMapAdapter(map); } 2962 2963    /** 2964     * Returns an adaption of a primitive map from 2965     * double keys to char values to a map. 2966     * 2967     * @param map 2968     * the primitive map to adapt. 2969     * 2970     * @return an adaption of the specified primitive 2971     * map to a map. 2972     */ 2973    public static Map asObjects(DoubleKeyCharMap map) 2974    { return new DoubleKeyCharMapToMapAdapter(map); } 2975 2976    /** 2977     * Returns an adaption of a primitive map from 2978     * double keys to byte values to a map. 2979     * 2980     * @param map 2981     * the primitive map to adapt. 2982     * 2983     * @return an adaption of the specified primitive 2984     * map to a map. 2985     */ 2986    public static Map asObjects(DoubleKeyByteMap map) 2987    { return new DoubleKeyByteMapToMapAdapter(map); } 2988 2989    /** 2990     * Returns an adaption of a primitive map from 2991     * double keys to short values to a map. 2992     * 2993     * @param map 2994     * the primitive map to adapt. 2995     * 2996     * @return an adaption of the specified primitive 2997     * map to a map. 2998     */ 2999    public static Map asObjects(DoubleKeyShortMap map) 3000    { return new DoubleKeyShortMapToMapAdapter(map); } 3001 3002    /** 3003     * Returns an adaption of a primitive map from 3004     * double keys to int values to a map. 3005     * 3006     * @param map 3007     * the primitive map to adapt. 3008     * 3009     * @return an adaption of the specified primitive 3010     * map to a map. 3011     */ 3012    public static Map asObjects(DoubleKeyIntMap map) 3013    { return new DoubleKeyIntMapToMapAdapter(map); } 3014 3015    /** 3016     * Returns an adaption of a primitive map from 3017     * double keys to long values to a map. 3018     * 3019     * @param map 3020     * the primitive map to adapt. 3021     * 3022     * @return an adaption of the specified primitive 3023     * map to a map. 3024     */ 3025    public static Map asObjects(DoubleKeyLongMap map) 3026    { return new DoubleKeyLongMapToMapAdapter(map); } 3027 3028    /** 3029     * Returns an adaption of a primitive map from 3030     * double keys to float values to a map. 3031     * 3032     * @param map 3033     * the primitive map to adapt. 3034     * 3035     * @return an adaption of the specified primitive 3036     * map to a map. 3037     */ 3038    public static Map asObjects(DoubleKeyFloatMap map) 3039    { return new DoubleKeyFloatMapToMapAdapter(map); } 3040 3041    /** 3042     * Returns an adaption of a primitive map from 3043     * double keys to double values to a map. 3044     * 3045     * @param map 3046     * the primitive map to adapt. 3047     * 3048     * @return an adaption of the specified primitive 3049     * map to a map. 3050     */ 3051    public static Map asObjects(DoubleKeyDoubleMap map) 3052    { return new DoubleKeyDoubleMapToMapAdapter(map); } 3053 3054    // --------------------------------------------------------------- 3055 // TKeyMap -> Map 3056 // --------------------------------------------------------------- 3057 3058    /** 3059     * Returns an adaption of a primitive map of boolean keys 3060     * to a map. 3061     * 3062     * @param map 3063     * the primitive map to adapt. 3064     * 3065     * @return an adaption of the specified primitive map 3066     * to a map. 3067     */ 3068    public static Map asObjects(BooleanKeyMap map) 3069    { return new BooleanKeyMapToMapAdapter(map); } 3070 3071    /** 3072     * Returns an adaption of a primitive map of char keys 3073     * to a map. 3074     * 3075     * @param map 3076     * the primitive map to adapt. 3077     * 3078     * @return an adaption of the specified primitive map 3079     * to a map. 3080     */ 3081    public static Map asObjects(CharKeyMap map) 3082    { return new CharKeyMapToMapAdapter(map); } 3083 3084    /** 3085     * Returns an adaption of a primitive map of byte keys 3086     * to a map. 3087     * 3088     * @param map 3089     * the primitive map to adapt. 3090     * 3091     * @return an adaption of the specified primitive map 3092     * to a map. 3093     */ 3094    public static Map asObjects(ByteKeyMap map) 3095    { return new ByteKeyMapToMapAdapter(map); } 3096 3097    /** 3098     * Returns an adaption of a primitive map of short keys 3099     * to a map. 3100     * 3101     * @param map 3102     * the primitive map to adapt. 3103     * 3104     * @return an adaption of the specified primitive map 3105     * to a map. 3106     */ 3107    public static Map asObjects(ShortKeyMap map) 3108    { return new ShortKeyMapToMapAdapter(map); } 3109 3110    /** 3111     * Returns an adaption of a primitive map of int keys 3112     * to a map. 3113     * 3114     * @param map 3115     * the primitive map to adapt. 3116     * 3117     * @return an adaption of the specified primitive map 3118     * to a map. 3119     */ 3120    public static Map asObjects(IntKeyMap map) 3121    { return new IntKeyMapToMapAdapter(map); } 3122 3123    /** 3124     * Returns an adaption of a primitive map of long keys 3125     * to a map. 3126     * 3127     * @param map 3128     * the primitive map to adapt. 3129     * 3130     * @return an adaption of the specified primitive map 3131     * to a map. 3132     */ 3133    public static Map asObjects(LongKeyMap map) 3134    { return new LongKeyMapToMapAdapter(map); } 3135 3136    /** 3137     * Returns an adaption of a primitive map of float keys 3138     * to a map. 3139     * 3140     * @param map 3141     * the primitive map to adapt. 3142     * 3143     * @return an adaption of the specified primitive map 3144     * to a map. 3145     */ 3146    public static Map asObjects(FloatKeyMap map) 3147    { return new FloatKeyMapToMapAdapter(map); } 3148 3149    /** 3150     * Returns an adaption of a primitive map of double keys 3151     * to a map. 3152     * 3153     * @param map 3154     * the primitive map to adapt. 3155     * 3156     * @return an adaption of the specified primitive map 3157     * to a map. 3158     */ 3159    public static Map asObjects(DoubleKeyMap map) 3160    { return new DoubleKeyMapToMapAdapter(map); } 3161 3162 3163    // --------------------------------------------------------------- 3164 // Map -> TKeyMap 3165 // --------------------------------------------------------------- 3166 3167    /** 3168     * Returns an adaption of a map to a primitive map 3169     * from boolean keys to objects. 3170     * 3171     * @param map 3172     * the map to adapt to a primitive map. 3173     * 3174     * @return an adaption of the specified map to 3175     * a primitive map. 3176     */ 3177    public static BooleanKeyMap asBooleanKeys(Map map) 3178    { return new MapToBooleanKeyMapAdapter(map); } 3179 3180    /** 3181     * Returns an adaption of a map to a primitive map 3182     * from char keys to objects. 3183     * 3184     * @param map 3185     * the map to adapt to a primitive map. 3186     * 3187     * @return an adaption of the specified map to 3188     * a primitive map. 3189     */ 3190    public static CharKeyMap asCharKeys(Map map) 3191    { return new MapToCharKeyMapAdapter(map); } 3192 3193    /** 3194     * Returns an adaption of a map to a primitive map 3195     * from byte keys to objects. 3196     * 3197     * @param map 3198     * the map to adapt to a primitive map. 3199     * 3200     * @return an adaption of the specified map to 3201     * a primitive map. 3202     */ 3203    public static ByteKeyMap asByteKeys(Map map) 3204    { return new MapToByteKeyMapAdapter(map); } 3205 3206    /** 3207     * Returns an adaption of a map to a primitive map 3208     * from short keys to objects. 3209     * 3210     * @param map 3211     * the map to adapt to a primitive map. 3212     * 3213     * @return an adaption of the specified map to 3214     * a primitive map. 3215     */ 3216    public static ShortKeyMap asShortKeys(Map map) 3217    { return new MapToShortKeyMapAdapter(map); } 3218 3219    /** 3220     * Returns an adaption of a map to a primitive map 3221     * from int keys to objects. 3222     * 3223     * @param map 3224     * the map to adapt to a primitive map. 3225     * 3226     * @return an adaption of the specified map to 3227     * a primitive map. 3228     */ 3229    public static IntKeyMap asIntKeys(Map map) 3230    { return new MapToIntKeyMapAdapter(map); } 3231 3232    /** 3233     * Returns an adaption of a map to a primitive map 3234     * from long keys to objects. 3235     * 3236     * @param map 3237     * the map to adapt to a primitive map. 3238     * 3239     * @return an adaption of the specified map to 3240     * a primitive map. 3241     */ 3242    public static LongKeyMap asLongKeys(Map map) 3243    { return new MapToLongKeyMapAdapter(map); } 3244 3245    /** 3246     * Returns an adaption of a map to a primitive map 3247     * from float keys to objects. 3248     * 3249     * @param map 3250     * the map to adapt to a primitive map. 3251     * 3252     * @return an adaption of the specified map to 3253     * a primitive map. 3254     */ 3255    public static FloatKeyMap asFloatKeys(Map map) 3256    { return new MapToFloatKeyMapAdapter(map); } 3257 3258    /** 3259     * Returns an adaption of a map to a primitive map 3260     * from double keys to objects. 3261     * 3262     * @param map 3263     * the map to adapt to a primitive map. 3264     * 3265     * @return an adaption of the specified map to 3266     * a primitive map. 3267     */ 3268    public static DoubleKeyMap asDoubleKeys(Map map) 3269    { return new MapToDoubleKeyMapAdapter(map); } 3270 3271    // --------------------------------------------------------------- 3272 // ObjectKeyTMap -> Map 3273 // --------------------------------------------------------------- 3274 3275    /** 3276     * Returns an adaption of a primitive map of object keys 3277     * and boolean values to a map. 3278     * 3279     * @param map 3280     * the primitive map to adapt. 3281     * 3282     * @return an adaption of the specified primitive map 3283     * to a map. 3284     * 3285     * @throws NullPointerException 3286     * if <tt>map</tt> is <tt>null</tt>. 3287     * 3288     * @since 1.1 3289     */ 3290    public static Map asObjects(ObjectKeyBooleanMap map) 3291    { return new ObjectKeyBooleanMapToMapAdapter(map); } 3292 3293    /** 3294     * Returns an adaption of a primitive map of object keys 3295     * and char values to a map. 3296     * 3297     * @param map 3298     * the primitive map to adapt. 3299     * 3300     * @return an adaption of the specified primitive map 3301     * to a map. 3302     * 3303     * @throws NullPointerException 3304     * if <tt>map</tt> is <tt>null</tt>. 3305     * 3306     * @since 1.1 3307     */ 3308    public static Map asObjects(ObjectKeyCharMap map) 3309    { return new ObjectKeyCharMapToMapAdapter(map); } 3310 3311    /** 3312     * Returns an adaption of a primitive map of object keys 3313     * and byte values to a map. 3314     * 3315     * @param map 3316     * the primitive map to adapt. 3317     * 3318     * @return an adaption of the specified primitive map 3319     * to a map. 3320     * 3321     * @throws NullPointerException 3322     * if <tt>map</tt> is <tt>null</tt>. 3323     * 3324     * @since 1.1 3325     */ 3326    public static Map asObjects(ObjectKeyByteMap map) 3327    { return new ObjectKeyByteMapToMapAdapter(map); } 3328 3329    /** 3330     * Returns an adaption of a primitive map of object keys 3331     * and short values to a map. 3332     * 3333     * @param map 3334     * the primitive map to adapt. 3335     * 3336     * @return an adaption of the specified primitive map 3337     * to a map. 3338     * 3339     * @throws NullPointerException 3340     * if <tt>map</tt> is <tt>null</tt>. 3341     * 3342     * @since 1.1 3343     */ 3344    public static Map asObjects(ObjectKeyShortMap map) 3345    { return new ObjectKeyShortMapToMapAdapter(map); } 3346 3347    /** 3348     * Returns an adaption of a primitive map of object keys 3349     * and int values to a map. 3350     * 3351     * @param map 3352     * the primitive map to adapt. 3353     * 3354     * @return an adaption of the specified primitive map 3355     * to a map. 3356     * 3357     * @throws NullPointerException 3358     * if <tt>map</tt> is <tt>null</tt>. 3359     * 3360     * @since 1.1 3361     */ 3362    public static Map asObjects(ObjectKeyIntMap map) 3363    { return new ObjectKeyIntMapToMapAdapter(map); } 3364 3365    /** 3366     * Returns an adaption of a primitive map of object keys 3367     * and long values to a map. 3368     * 3369     * @param map 3370     * the primitive map to adapt. 3371     * 3372     * @return an adaption of the specified primitive map 3373     * to a map. 3374     * 3375     * @throws NullPointerException 3376     * if <tt>map</tt> is <tt>null</tt>. 3377     * 3378     * @since 1.1 3379     */ 3380    public static Map asObjects(ObjectKeyLongMap map) 3381    { return new ObjectKeyLongMapToMapAdapter(map); } 3382 3383    /** 3384     * Returns an adaption of a primitive map of object keys 3385     * and float values to a map. 3386     * 3387     * @param map 3388     * the primitive map to adapt. 3389     * 3390     * @return an adaption of the specified primitive map 3391     * to a map. 3392     * 3393     * @throws NullPointerException 3394     * if <tt>map</tt> is <tt>null</tt>. 3395     * 3396     * @since 1.1 3397     */ 3398    public static Map asObjects(ObjectKeyFloatMap map) 3399    { return new ObjectKeyFloatMapToMapAdapter(map); } 3400 3401    /** 3402     * Returns an adaption of a primitive map of object keys 3403     * and double values to a map. 3404     * 3405     * @param map 3406     * the primitive map to adapt. 3407     * 3408     * @return an adaption of the specified primitive map 3409     * to a map. 3410     * 3411     * @throws NullPointerException 3412     * if <tt>map</tt> is <tt>null</tt>. 3413     * 3414     * @since 1.1 3415     */ 3416    public static Map asObjects(ObjectKeyDoubleMap map) 3417    { return new ObjectKeyDoubleMapToMapAdapter(map); } 3418 3419    // --------------------------------------------------------------- 3420 // Map -> ObjectKeyTMap 3421 // --------------------------------------------------------------- 3422 3423    /** 3424     * Returns an adaption of a map to a primitive map 3425     * from object keys to boolean values. 3426     * 3427     * @param map 3428     * the map to adapt to a primitive map. 3429     * 3430     * @return an adaption of the specified map to 3431     * a primitive map. 3432     * 3433     * @throws NullPointerException 3434     * if <tt>map</tt> is <tt>null</tt>. 3435     * 3436     * @since 1.1 3437     */ 3438    public static ObjectKeyBooleanMap asObjectKeyBooleans(Map map) 3439    { return new MapToObjectKeyBooleanMapAdapter(map); } 3440 3441    /** 3442     * Returns an adaption of a map to a primitive map 3443     * from object keys to char values. 3444     * 3445     * @param map 3446     * the map to adapt to a primitive map. 3447     * 3448     * @return an adaption of the specified map to 3449     * a primitive map. 3450     * 3451     * @throws NullPointerException 3452     * if <tt>map</tt> is <tt>null</tt>. 3453     * 3454     * @since 1.1 3455     */ 3456    public static ObjectKeyCharMap asObjectKeyChars(Map map) 3457    { return new MapToObjectKeyCharMapAdapter(map); } 3458 3459    /** 3460     * Returns an adaption of a map to a primitive map 3461     * from object keys to byte values. 3462     * 3463     * @param map 3464     * the map to adapt to a primitive map. 3465     * 3466     * @return an adaption of the specified map to 3467     * a primitive map. 3468     * 3469     * @throws NullPointerException 3470     * if <tt>map</tt> is <tt>null</tt>. 3471     * 3472     * @since 1.1 3473     */ 3474    public static ObjectKeyByteMap asObjectKeyBytes(Map map) 3475    { return new MapToObjectKeyByteMapAdapter(map); } 3476 3477    /** 3478     * Returns an adaption of a map to a primitive map 3479     * from object keys to short values. 3480     * 3481     * @param map 3482     * the map to adapt to a primitive map. 3483     * 3484     * @return an adaption of the specified map to 3485     * a primitive map. 3486     * 3487     * @throws NullPointerException 3488     * if <tt>map</tt> is <tt>null</tt>. 3489     * 3490     * @since 1.1 3491     */ 3492    public static ObjectKeyShortMap asObjectKeyShorts(Map map) 3493    { return new MapToObjectKeyShortMapAdapter(map); } 3494 3495    /** 3496     * Returns an adaption of a map to a primitive map 3497     * from object keys to int values. 3498     * 3499     * @param map 3500     * the map to adapt to a primitive map. 3501     * 3502     * @return an adaption of the specified map to 3503     * a primitive map. 3504     * 3505     * @throws NullPointerException 3506     * if <tt>map</tt> is <tt>null</tt>. 3507     * 3508     * @since 1.1 3509     */ 3510    public static ObjectKeyIntMap asObjectKeyInts(Map map) 3511    { return new MapToObjectKeyIntMapAdapter(map); } 3512 3513    /** 3514     * Returns an adaption of a map to a primitive map 3515     * from object keys to long values. 3516     * 3517     * @param map 3518     * the map to adapt to a primitive map. 3519     * 3520     * @return an adaption of the specified map to 3521     * a primitive map. 3522     * 3523     * @throws NullPointerException 3524     * if <tt>map</tt> is <tt>null</tt>. 3525     * 3526     * @since 1.1 3527     */ 3528    public static ObjectKeyLongMap asObjectKeyLongs(Map map) 3529    { return new MapToObjectKeyLongMapAdapter(map); } 3530 3531    /** 3532     * Returns an adaption of a map to a primitive map 3533     * from object keys to float values. 3534     * 3535     * @param map 3536     * the map to adapt to a primitive map. 3537     * 3538     * @return an adaption of the specified map to 3539     * a primitive map. 3540     * 3541     * @throws NullPointerException 3542     * if <tt>map</tt> is <tt>null</tt>. 3543     * 3544     * @since 1.1 3545     */ 3546    public static ObjectKeyFloatMap asObjectKeyFloats(Map map) 3547    { return new MapToObjectKeyFloatMapAdapter(map); } 3548 3549    /** 3550     * Returns an adaption of a map to a primitive map 3551     * from object keys to double values. 3552     * 3553     * @param map 3554     * the map to adapt to a primitive map. 3555     * 3556     * @return an adaption of the specified map to 3557     * a primitive map. 3558     * 3559     * @throws NullPointerException 3560     * if <tt>map</tt> is <tt>null</tt>. 3561     * 3562     * @since 1.1 3563     */ 3564    public static ObjectKeyDoubleMap asObjectKeyDoubles(Map map) 3565    { return new MapToObjectKeyDoubleMapAdapter(map); } 3566 3567    // --------------------------------------------------------------- 3568 // isTAdaptable(Collection c) 3569 // --------------------------------------------------------------- 3570 3571    /** 3572     * Indicates whether a specified collection is adaptable 3573     * to a primitive collection of boolean values. For a 3574     * collection to be adaptable it can only contain 3575     * values of class {@link Boolean Boolean} and no 3576     * <tt>null</tt> values. 3577     * 3578     * @param collection 3579     * the collection to examine. 3580     * 3581     * @return <tt>true</tt> if <tt>collection</tt> is adaptable to a 3582     * {@link BooleanCollection BooleanCollection}; 3583     * returns <tt>false</tt> otherwise. 3584     * 3585     * @throws NullPointerException 3586     * if <tt>collection</tt> is <tt>null</tt>. 3587     * 3588     * @see #asBooleans(Collection) 3589     * @see #asBooleans(List) 3590     * @see #asBooleans(Set) 3591     */ 3592    public static boolean isBooleanAdaptable(Collection collection) { 3593        for (Iterator i = collection.iterator(); i.hasNext(); ) 3594            if (!(i.next() instanceof Boolean )) 3595                return false; 3596        return true; 3597    } 3598 3599    /** 3600     * Indicates whether a specified collection is adaptable 3601     * to a primitive collection of char values. For a 3602     * collection to be adaptable it can only contain 3603     * values of class {@link Character Character} and no 3604     * <tt>null</tt> values. 3605     * 3606     * @param collection 3607     * the collection to examine. 3608     * 3609     * @return <tt>true</tt> if <tt>collection</tt> is adaptable to a 3610     * {@link CharCollection CharCollection}; 3611     * returns <tt>false</tt> otherwise. 3612     * 3613     * @throws NullPointerException 3614     * if <tt>collection</tt> is <tt>null</tt>. 3615     * 3616     * @see #asChars(Collection) 3617     * @see #asChars(List) 3618     * @see #asChars(Set) 3619     */ 3620    public static boolean isCharAdaptable(Collection collection) { 3621        for (Iterator i = collection.iterator(); i.hasNext(); ) 3622            if (!(i.next() instanceof Character )) 3623                return false; 3624        return true; 3625    } 3626 3627    /** 3628     * Indicates whether a specified collection is adaptable 3629     * to a primitive collection of byte values. For a 3630     * collection to be adaptable it can only contain 3631     * values of class {@link Byte Byte} and no 3632     * <tt>null</tt> values. 3633     * 3634     * @param collection 3635     * the collection to examine. 3636     * 3637     * @return <tt>true</tt> if <tt>collection</tt> is adaptable to a 3638     * {@link ByteCollection ByteCollection}; 3639     * returns <tt>false</tt> otherwise. 3640     * 3641     * @throws NullPointerException 3642     * if <tt>collection</tt> is <tt>null</tt>. 3643     * 3644     * @see #asBytes(Collection) 3645     * @see #asBytes(List) 3646     * @see #asBytes(Set) 3647     */ 3648    public static boolean isByteAdaptable(Collection collection) { 3649        for (Iterator i = collection.iterator(); i.hasNext(); ) 3650            if (!(i.next() instanceof Byte )) 3651                return false; 3652        return true; 3653    } 3654 3655    /** 3656     * Indicates whether a specified collection is adaptable 3657     * to a primitive collection of short values. For a 3658     * collection to be adaptable it can only contain 3659     * values of class {@link Short Short} and no 3660     * <tt>null</tt> values. 3661     * 3662     * @param collection 3663     * the collection to examine. 3664     * 3665     * @return <tt>true</tt> if <tt>collection</tt> is adaptable to a 3666     * {@link ShortCollection ShortCollection}; 3667     * returns <tt>false</tt> otherwise. 3668     * 3669     * @throws NullPointerException 3670     * if <tt>collection</tt> is <tt>null</tt>. 3671     * 3672     * @see #asShorts(Collection) 3673     * @see #asShorts(List) 3674     * @see #asShorts(Set) 3675     */ 3676    public static boolean isShortAdaptable(Collection collection) { 3677        for (Iterator i = collection.iterator(); i.hasNext(); ) 3678            if (!(i.next() instanceof Short )) 3679                return false; 3680        return true; 3681    } 3682 3683    /** 3684     * Indicates whether a specified collection is adaptable 3685     * to a primitive collection of int values. For a 3686     * collection to be adaptable it can only contain 3687     * values of class {@link Integer Integer} and no 3688     * <tt>null</tt> values. 3689     * 3690     * @param collection 3691     * the collection to examine. 3692     * 3693     * @return <tt>true</tt> if <tt>collection</tt> is adaptable to a 3694     * {@link IntCollection IntCollection}; 3695     * returns <tt>false</tt> otherwise. 3696     * 3697     * @throws NullPointerException 3698     * if <tt>collection</tt> is <tt>null</tt>. 3699     * 3700     * @see #asInts(Collection) 3701     * @see #asInts(List) 3702     * @see #asInts(Set) 3703     */ 3704    public static boolean isIntAdaptable(Collection collection) { 3705        for (Iterator i = collection.iterator(); i.hasNext(); ) 3706            if (!(i.next() instanceof Integer )) 3707                return false; 3708        return true; 3709    } 3710 3711    /** 3712     * Indicates whether a specified collection is adaptable 3713     * to a primitive collection of long values. For a 3714     * collection to be adaptable it can only contain 3715     * values of class {@link Long Long} and no 3716     * <tt>null</tt> values. 3717     * 3718     * @param collection 3719     * the collection to examine. 3720     * 3721     * @return <tt>true</tt> if <tt>collection</tt> is adaptable to a 3722     * {@link LongCollection LongCollection}; 3723     * returns <tt>false</tt> otherwise. 3724     * 3725     * @throws NullPointerException 3726     * if <tt>collection</tt> is <tt>null</tt>. 3727     * 3728     * @see #asLongs(Collection) 3729     * @see #asLongs(List) 3730     * @see #asLongs(Set) 3731     */ 3732    public static boolean isLongAdaptable(Collection collection) { 3733        for (Iterator i = collection.iterator(); i.hasNext(); ) 3734            if (!(i.next() instanceof Long )) 3735                return false; 3736        return true; 3737    } 3738 3739    /** 3740     * Indicates whether a specified collection is adaptable 3741     * to a primitive collection of float values. For a 3742     * collection to be adaptable it can only contain 3743     * values of class {@link Float Float} and no 3744     * <tt>null</tt> values. 3745     * 3746     * @param collection 3747     * the collection to examine. 3748     * 3749     * @return <tt>true</tt> if <tt>collection</tt> is adaptable to a 3750     * {@link FloatCollection FloatCollection}; 3751     * returns <tt>false</tt> otherwise. 3752     * 3753     * @throws NullPointerException 3754     * if <tt>collection</tt> is <tt>null</tt>. 3755     * 3756     * @see #asFloats(Collection) 3757     * @see #asFloats(List) 3758     * @see #asFloats(Set) 3759     */ 3760    public static boolean isFloatAdaptable(Collection collection) { 3761        for (Iterator i = collection.iterator(); i.hasNext(); ) 3762            if (!(i.next() instanceof Float )) 3763                return false; 3764        return true; 3765    } 3766 3767    /** 3768     * Indicates whether a specified collection is adaptable 3769     * to a primitive collection of double values. For a 3770     * collection to be adaptable it can only contain 3771     * values of class {@link Double Double} and no 3772     * <tt>null</tt> values. 3773     * 3774     * @param collection 3775     * the collection to examine. 3776     * 3777     * @return <tt>true</tt> if <tt>collection</tt> is adaptable to a 3778     * {@link DoubleCollection DoubleCollection}; 3779     * returns <tt>false</tt> otherwise. 3780     * 3781     * @throws NullPointerException 3782     * if <tt>collection</tt> is <tt>null</tt>. 3783     * 3784     * @see #asDoubles(Collection) 3785     * @see #asDoubles(List) 3786     * @see #asDoubles(Set) 3787     */ 3788    public static boolean isDoubleAdaptable(Collection collection) { 3789        for (Iterator i = collection.iterator(); i.hasNext(); ) 3790            if (!(i.next() instanceof Double )) 3791                return false; 3792        return true; 3793    } 3794 3795    // --------------------------------------------------------------- 3796 // isTKeyAdaptable(Map map) 3797 // --------------------------------------------------------------- 3798 3799    /** 3800     * Indicates whether a specified map is adaptable 3801     * to a primitive map with boolean keys. For a 3802     * map to be adaptable it can only contain 3803     * keys of class {@link Boolean Boolean} and no 3804     * <tt>null</tt> keys. 3805     * 3806     * @param map 3807     * the map to examine. 3808     * 3809     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 3810     * {@link BooleanKeyMap BooleanKeyMap}; 3811     * returns <tt>false</tt> otherwise. 3812     * 3813     * @throws NullPointerException 3814     * if <tt>map</tt> is <tt>null</tt>. 3815     * 3816     * @see #asBooleanKeys(Map) 3817     */ 3818    public static boolean isBooleanKeyAdaptable(Map map) 3819    { return isBooleanAdaptable(map.keySet()); } 3820 3821    /** 3822     * Indicates whether a specified map is adaptable 3823     * to a primitive map with char keys. For a 3824     * map to be adaptable it can only contain 3825     * keys of class {@link Character Character} and no 3826     * <tt>null</tt> keys. 3827     * 3828     * @param map 3829     * the map to examine. 3830     * 3831     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 3832     * {@link CharKeyMap CharKeyMap}; 3833     * returns <tt>false</tt> otherwise. 3834     * 3835     * @throws NullPointerException 3836     * if <tt>map</tt> is <tt>null</tt>. 3837     * 3838     * @see #asCharKeys(Map) 3839     */ 3840    public static boolean isCharKeyAdaptable(Map map) 3841    { return isCharAdaptable(map.keySet()); } 3842 3843    /** 3844     * Indicates whether a specified map is adaptable 3845     * to a primitive map with byte keys. For a 3846     * map to be adaptable it can only contain 3847     * keys of class {@link Byte Byte} and no 3848     * <tt>null</tt> keys. 3849     * 3850     * @param map 3851     * the map to examine. 3852     * 3853     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 3854     * {@link ByteKeyMap ByteKeyMap}; 3855     * returns <tt>false</tt> otherwise. 3856     * 3857     * @throws NullPointerException 3858     * if <tt>map</tt> is <tt>null</tt>. 3859     * 3860     * @see #asByteKeys(Map) 3861     */ 3862    public static boolean isByteKeyAdaptable(Map map) 3863    { return isByteAdaptable(map.keySet()); } 3864 3865    /** 3866     * Indicates whether a specified map is adaptable 3867     * to a primitive map with short keys. For a 3868     * map to be adaptable it can only contain 3869     * keys of class {@link Short Short} and no 3870     * <tt>null</tt> keys. 3871     * 3872     * @param map 3873     * the map to examine. 3874     * 3875     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 3876     * {@link ShortKeyMap ShortKeyMap}; 3877     * returns <tt>false</tt> otherwise. 3878     * 3879     * @throws NullPointerException 3880     * if <tt>map</tt> is <tt>null</tt>. 3881     * 3882     * @see #asShortKeys(Map) 3883     */ 3884    public static boolean isShortKeyAdaptable(Map map) 3885    { return isShortAdaptable(map.keySet()); } 3886 3887    /** 3888     * Indicates whether a specified map is adaptable 3889     * to a primitive map with int keys. For a 3890     * map to be adaptable it can only contain 3891     * keys of class {@link Integer Integer} and no 3892     * <tt>null</tt> keys. 3893     * 3894     * @param map 3895     * the map to examine. 3896     * 3897     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 3898     * {@link IntKeyMap IntKeyMap}; 3899     * returns <tt>false</tt> otherwise. 3900     * 3901     * @throws NullPointerException 3902     * if <tt>map</tt> is <tt>null</tt>. 3903     * 3904     * @see #asIntKeys(Map) 3905     */ 3906    public static boolean isIntKeyAdaptable(Map map) 3907    { return isIntAdaptable(map.keySet()); } 3908 3909    /** 3910     * Indicates whether a specified map is adaptable 3911     * to a primitive map with long keys. For a 3912     * map to be adaptable it can only contain 3913     * keys of class {@link Long Long} and no 3914     * <tt>null</tt> keys. 3915     * 3916     * @param map 3917     * the map to examine. 3918     * 3919     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 3920     * {@link LongKeyMap LongKeyMap}; 3921     * returns <tt>false</tt> otherwise. 3922     * 3923     * @throws NullPointerException 3924     * if <tt>map</tt> is <tt>null</tt>. 3925     * 3926     * @see #asLongKeys(Map) 3927     */ 3928    public static boolean isLongKeyAdaptable(Map map) 3929    { return isLongAdaptable(map.keySet()); } 3930 3931    /** 3932     * Indicates whether a specified map is adaptable 3933     * to a primitive map with float keys. For a 3934     * map to be adaptable it can only contain 3935     * keys of class {@link Float Float} and no 3936     * <tt>null</tt> keys. 3937     * 3938     * @param map 3939     * the map to examine. 3940     * 3941     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 3942     * {@link FloatKeyMap FloatKeyMap}; 3943     * returns <tt>false</tt> otherwise. 3944     * 3945     * @throws NullPointerException 3946     * if <tt>map</tt> is <tt>null</tt>. 3947     * 3948     * @see #asFloatKeys(Map) 3949     */ 3950    public static boolean isFloatKeyAdaptable(Map map) 3951    { return isFloatAdaptable(map.keySet()); } 3952 3953    /** 3954     * Indicates whether a specified map is adaptable 3955     * to a primitive map with double keys. For a 3956     * map to be adaptable it can only contain 3957     * keys of class {@link Double Double} and no 3958     * <tt>null</tt> keys. 3959     * 3960     * @param map 3961     * the map to examine. 3962     * 3963     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 3964     * {@link DoubleKeyMap DoubleKeyMap}; 3965     * returns <tt>false</tt> otherwise. 3966     * 3967     * @throws NullPointerException 3968     * if <tt>map</tt> is <tt>null</tt>. 3969     * 3970     * @see #asDoubleKeys(Map) 3971     */ 3972    public static boolean isDoubleKeyAdaptable(Map map) 3973    { return isDoubleAdaptable(map.keySet()); } 3974 3975    // --------------------------------------------------------------- 3976 // isTKeySAdaptable(Map map) 3977 // --------------------------------------------------------------- 3978 3979    /** 3980     * Indicates whether a specified map is adaptable 3981     * to a primitive map with boolean keys and boolean values. For a 3982     * map to be adaptable it can only contain 3983     * keys of class {@link Boolean Boolean}, 3984     * values of class {@link Boolean Boolean}, 3985     * and no <tt>null</tt> keys or <tt>null</tt> values. 3986     * 3987     * @param map 3988     * the map to examine. 3989     * 3990     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 3991     * {@link BooleanKeyBooleanMap BooleanKeyBooleanMap}; 3992     * returns <tt>false</tt> otherwise. 3993     * 3994     * @throws NullPointerException 3995     * if <tt>map</tt> is <tt>null</tt>. 3996     * 3997     * @see #asBooleanKeyBooleans(Map) 3998     */ 3999    public static boolean isBooleanKeyBooleanAdaptable(Map map) 4000    { return isBooleanAdaptable(map.keySet()) && isBooleanAdaptable(map.values()); } 4001     4002    /** 4003     * Indicates whether a specified map is adaptable 4004     * to a primitive map with boolean keys and char values. For a 4005     * map to be adaptable it can only contain 4006     * keys of class {@link Boolean Boolean}, 4007     * values of class {@link Character Character}, 4008     * and no <tt>null</tt> keys or <tt>null</tt> values. 4009     * 4010     * @param map 4011     * the map to examine. 4012     * 4013     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4014     * {@link BooleanKeyCharMap BooleanKeyCharMap}; 4015     * returns <tt>false</tt> otherwise. 4016     * 4017     * @throws NullPointerException 4018     * if <tt>map</tt> is <tt>null</tt>. 4019     * 4020     * @see #asBooleanKeyChars(Map) 4021     */ 4022    public static boolean isBooleanKeyCharAdaptable(Map map) 4023    { return isBooleanAdaptable(map.keySet()) && isCharAdaptable(map.values()); } 4024 4025    /** 4026     * Indicates whether a specified map is adaptable 4027     * to a primitive map with boolean keys and byte values. For a 4028     * map to be adaptable it can only contain 4029     * keys of class {@link Boolean Boolean}, 4030     * values of class {@link Byte Byte}, 4031     * and no <tt>null</tt> keys or <tt>null</tt> values. 4032     * 4033     * @param map 4034     * the map to examine. 4035     * 4036     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4037     * {@link BooleanKeyByteMap BooleanKeyByteMap}; 4038     * returns <tt>false</tt> otherwise. 4039     * 4040     * @throws NullPointerException 4041     * if <tt>map</tt> is <tt>null</tt>. 4042     * 4043     * @see #asBooleanKeyBytes(Map) 4044     */ 4045    public static boolean isBooleanKeyByteAdaptable(Map map) 4046    { return isBooleanAdaptable(map.keySet()) && isByteAdaptable(map.values()); } 4047     4048    /** 4049     * Indicates whether a specified map is adaptable 4050     * to a primitive map with boolean keys and short values. For a 4051     * map to be adaptable it can only contain 4052     * keys of class {@link Boolean Boolean}, 4053     * values of class {@link Short Short}, 4054     * and no <tt>null</tt> keys or <tt>null</tt> values. 4055     * 4056     * @param map 4057     * the map to examine. 4058     * 4059     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4060     * {@link BooleanKeyShortMap BooleanKeyShortMap}; 4061     * returns <tt>false</tt> otherwise. 4062     * 4063     * @throws NullPointerException 4064     * if <tt>map</tt> is <tt>null</tt>. 4065     * 4066     * @see #asBooleanKeyShorts(Map) 4067     */ 4068    public static boolean isBooleanKeyShortAdaptable(Map map) 4069    { return isBooleanAdaptable(map.keySet()) && isShortAdaptable(map.values()); } 4070     4071    /** 4072     * Indicates whether a specified map is adaptable 4073     * to a primitive map with boolean keys and int values. For a 4074     * map to be adaptable it can only contain 4075     * keys of class {@link Boolean Boolean}, 4076     * values of class {@link Integer Integer}, 4077     * and no <tt>null</tt> keys or <tt>null</tt> values. 4078     * 4079     * @param map 4080     * the map to examine. 4081     * 4082     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4083     * {@link BooleanKeyIntMap BooleanKeyIntMap}; 4084     * returns <tt>false</tt> otherwise. 4085     * 4086     * @throws NullPointerException 4087     * if <tt>map</tt> is <tt>null</tt>. 4088     * 4089     * @see #asBooleanKeyInts(Map) 4090     */ 4091    public static boolean isBooleanKeyIntAdaptable(Map map) 4092    { return isBooleanAdaptable(map.keySet()) && isIntAdaptable(map.values()); } 4093     4094    /** 4095     * Indicates whether a specified map is adaptable 4096     * to a primitive map with boolean keys and long values. For a 4097     * map to be adaptable it can only contain 4098     * keys of class {@link Boolean Boolean}, 4099     * values of class {@link Long Long}, 4100     * and no <tt>null</tt> keys or <tt>null</tt> values. 4101     * 4102     * @param map 4103     * the map to examine. 4104     * 4105     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4106     * {@link BooleanKeyLongMap BooleanKeyLongMap}; 4107     * returns <tt>false</tt> otherwise. 4108     * 4109     * @throws NullPointerException 4110     * if <tt>map</tt> is <tt>null</tt>. 4111     * 4112     * @see #asBooleanKeyLongs(Map) 4113     */ 4114    public static boolean isBooleanKeyLongAdaptable(Map map) 4115    { return isBooleanAdaptable(map.keySet()) && isLongAdaptable(map.values()); } 4116     4117    /** 4118     * Indicates whether a specified map is adaptable 4119     * to a primitive map with boolean keys and float values. For a 4120     * map to be adaptable it can only contain 4121     * keys of class {@link Boolean Boolean}, 4122     * values of class {@link Float Float}, 4123     * and no <tt>null</tt> keys or <tt>null</tt> values. 4124     * 4125     * @param map 4126     * the map to examine. 4127     * 4128     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4129     * {@link BooleanKeyFloatMap BooleanKeyFloatMap}; 4130     * returns <tt>false</tt> otherwise. 4131     * 4132     * @throws NullPointerException 4133     * if <tt>map</tt> is <tt>null</tt>. 4134     * 4135     * @see #asBooleanKeyFloats(Map) 4136     */ 4137    public static boolean isBooleanKeyFloatAdaptable(Map map) 4138    { return isBooleanAdaptable(map.keySet()) && isFloatAdaptable(map.values()); } 4139     4140    /** 4141     * Indicates whether a specified map is adaptable 4142     * to a primitive map with boolean keys and double values. For a 4143     * map to be adaptable it can only contain 4144     * keys of class {@link Boolean Boolean}, 4145     * values of class {@link Double Double}, 4146     * and no <tt>null</tt> keys or <tt>null</tt> values. 4147     * 4148     * @param map 4149     * the map to examine. 4150     * 4151     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4152     * {@link BooleanKeyDoubleMap BooleanKeyDoubleMap}; 4153     * returns <tt>false</tt> otherwise. 4154     * 4155     * @throws NullPointerException 4156     * if <tt>map</tt> is <tt>null</tt>. 4157     * 4158     * @see #asBooleanKeyDoubles(Map) 4159     */ 4160    public static boolean isBooleanKeyDoubleAdaptable(Map map) 4161    { return isBooleanAdaptable(map.keySet()) && isDoubleAdaptable(map.values()); } 4162     4163    /** 4164     * Indicates whether a specified map is adaptable 4165     * to a primitive map with char keys and boolean values. For a 4166     * map to be adaptable it can only contain 4167     * keys of class {@link Character Character}, 4168     * values of class {@link Boolean Boolean}, 4169     * and no <tt>null</tt> keys or <tt>null</tt> values. 4170     * 4171     * @param map 4172     * the map to examine. 4173     * 4174     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4175     * {@link CharKeyBooleanMap CharKeyBooleanMap}; 4176     * returns <tt>false</tt> otherwise. 4177     * 4178     * @throws NullPointerException 4179     * if <tt>map</tt> is <tt>null</tt>. 4180     * 4181     * @see #asCharKeyBooleans(Map) 4182     */ 4183    public static boolean isCharKeyBooleanAdaptable(Map map) 4184    { return isCharAdaptable(map.keySet()) && isBooleanAdaptable(map.values()); } 4185     4186    /** 4187     * Indicates whether a specified map is adaptable 4188     * to a primitive map with char keys and char values. For a 4189     * map to be adaptable it can only contain 4190     * keys of class {@link Character Character}, 4191     * values of class {@link Character Character}, 4192     * and no <tt>null</tt> keys or <tt>null</tt> values. 4193     * 4194     * @param map 4195     * the map to examine. 4196     * 4197     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4198     * {@link CharKeyCharMap CharKeyCharMap}; 4199     * returns <tt>false</tt> otherwise. 4200     * 4201     * @throws NullPointerException 4202     * if <tt>map</tt> is <tt>null</tt>. 4203     * 4204     * @see #asCharKeyChars(Map) 4205     */ 4206    public static boolean isCharKeyCharAdaptable(Map map) 4207    { return isCharAdaptable(map.keySet()) && isCharAdaptable(map.values()); } 4208     4209    /** 4210     * Indicates whether a specified map is adaptable 4211     * to a primitive map with char keys and byte values. For a 4212     * map to be adaptable it can only contain 4213     * keys of class {@link Character Character}, 4214     * values of class {@link Byte Byte}, 4215     * and no <tt>null</tt> keys or <tt>null</tt> values. 4216     * 4217     * @param map 4218     * the map to examine. 4219     * 4220     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4221     * {@link CharKeyByteMap CharKeyByteMap}; 4222     * returns <tt>false</tt> otherwise. 4223     * 4224     * @throws NullPointerException 4225     * if <tt>map</tt> is <tt>null</tt>. 4226     * 4227     * @see #asCharKeyBytes(Map) 4228     */ 4229    public static boolean isCharKeyByteAdaptable(Map map) 4230    { return isCharAdaptable(map.keySet()) && isByteAdaptable(map.values()); } 4231     4232    /** 4233     * Indicates whether a specified map is adaptable 4234     * to a primitive map with char keys and short values. For a 4235     * map to be adaptable it can only contain 4236     * keys of class {@link Character Character}, 4237     * values of class {@link Short Short}, 4238     * and no <tt>null</tt> keys or <tt>null</tt> values. 4239     * 4240     * @param map 4241     * the map to examine. 4242     * 4243     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4244     * {@link CharKeyShortMap CharKeyShortMap}; 4245     * returns <tt>false</tt> otherwise. 4246     * 4247     * @throws NullPointerException 4248     * if <tt>map</tt> is <tt>null</tt>. 4249     * 4250     * @see #asCharKeyShorts(Map) 4251     */ 4252    public static boolean isCharKeyShortAdaptable(Map map) 4253    { return isCharAdaptable(map.keySet()) && isShortAdaptable(map.values()); } 4254     4255    /** 4256     * Indicates whether a specified map is adaptable 4257     * to a primitive map with char keys and int values. For a 4258     * map to be adaptable it can only contain 4259     * keys of class {@link Character Character}, 4260     * values of class {@link Integer Integer}, 4261     * and no <tt>null</tt> keys or <tt>null</tt> values. 4262     * 4263     * @param map 4264     * the map to examine. 4265     * 4266     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4267     * {@link CharKeyIntMap CharKeyIntMap}; 4268     * returns <tt>false</tt> otherwise. 4269     * 4270     * @throws NullPointerException 4271     * if <tt>map</tt> is <tt>null</tt>. 4272     * 4273     * @see #asCharKeyInts(Map) 4274     */ 4275    public static boolean isCharKeyIntAdaptable(Map map) 4276    { return isCharAdaptable(map.keySet()) && isIntAdaptable(map.values()); } 4277     4278    /** 4279     * Indicates whether a specified map is adaptable 4280     * to a primitive map with char keys and long values. For a 4281     * map to be adaptable it can only contain 4282     * keys of class {@link Character Character}, 4283     * values of class {@link Long Long}, 4284     * and no <tt>null</tt> keys or <tt>null</tt> values. 4285     * 4286     * @param map 4287     * the map to examine. 4288     * 4289     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4290     * {@link CharKeyLongMap CharKeyLongMap}; 4291     * returns <tt>false</tt> otherwise. 4292     * 4293     * @throws NullPointerException 4294     * if <tt>map</tt> is <tt>null</tt>. 4295     * 4296     * @see #asCharKeyLongs(Map) 4297     */ 4298    public static boolean isCharKeyLongAdaptable(Map map) 4299    { return isCharAdaptable(map.keySet()) && isLongAdaptable(map.values()); } 4300     4301    /** 4302     * Indicates whether a specified map is adaptable 4303     * to a primitive map with char keys and float values. For a 4304     * map to be adaptable it can only contain 4305     * keys of class {@link Character Character}, 4306     * values of class {@link Float Float}, 4307     * and no <tt>null</tt> keys or <tt>null</tt> values. 4308     * 4309     * @param map 4310     * the map to examine. 4311     * 4312     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4313     * {@link CharKeyFloatMap CharKeyFloatMap}; 4314     * returns <tt>false</tt> otherwise. 4315     * 4316     * @throws NullPointerException 4317     * if <tt>map</tt> is <tt>null</tt>. 4318     * 4319     * @see #asCharKeyFloats(Map) 4320     */ 4321    public static boolean isCharKeyFloatAdaptable(Map map) 4322    { return isCharAdaptable(map.keySet()) && isFloatAdaptable(map.values()); } 4323     4324    /** 4325     * Indicates whether a specified map is adaptable 4326     * to a primitive map with char keys and double values. For a 4327     * map to be adaptable it can only contain 4328     * keys of class {@link Character Character}, 4329     * values of class {@link Double Double}, 4330     * and no <tt>null</tt> keys or <tt>null</tt> values. 4331     * 4332     * @param map 4333     * the map to examine. 4334     * 4335     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4336     * {@link CharKeyDoubleMap CharKeyDoubleMap}; 4337     * returns <tt>false</tt> otherwise. 4338     * 4339     * @throws NullPointerException 4340     * if <tt>map</tt> is <tt>null</tt>. 4341     * 4342     * @see #asCharKeyDoubles(Map) 4343     */ 4344    public static boolean isCharKeyDoubleAdaptable(Map map) 4345    { return isCharAdaptable(map.keySet()) && isDoubleAdaptable(map.values()); } 4346     4347     4348    /** 4349     * Indicates whether a specified map is adaptable 4350     * to a primitive map with byte keys and boolean values. For a 4351     * map to be adaptable it can only contain 4352     * keys of class {@link Byte Byte}, 4353     * values of class {@link Boolean Boolean}, 4354     * and no <tt>null</tt> keys or <tt>null</tt> values. 4355     * 4356     * @param map 4357     * the map to examine. 4358     * 4359     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4360     * {@link ByteKeyBooleanMap ByteKeyBooleanMap}; 4361     * returns <tt>false</tt> otherwise. 4362     * 4363     * @throws NullPointerException 4364     * if <tt>map</tt> is <tt>null</tt>. 4365     * 4366     * @see #asByteKeyBooleans(Map) 4367     */ 4368    public static boolean isByteKeyBooleanAdaptable(Map map) 4369    { return isByteAdaptable(map.keySet()) && isBooleanAdaptable(map.values()); } 4370     4371    /** 4372     * Indicates whether a specified map is adaptable 4373     * to a primitive map with byte keys and char values. For a 4374     * map to be adaptable it can only contain 4375     * keys of class {@link Byte Byte}, 4376     * values of class {@link Character Character}, 4377     * and no <tt>null</tt> keys or <tt>null</tt> values. 4378     * 4379     * @param map 4380     * the map to examine. 4381     * 4382     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4383     * {@link ByteKeyCharMap ByteKeyCharMap}; 4384     * returns <tt>false</tt> otherwise. 4385     * 4386     * @throws NullPointerException 4387     * if <tt>map</tt> is <tt>null</tt>. 4388     * 4389     * @see #asByteKeyChars(Map) 4390     */ 4391    public static boolean isByteKeyCharAdaptable(Map map) 4392    { return isByteAdaptable(map.keySet()) && isCharAdaptable(map.values()); } 4393     4394    /** 4395     * Indicates whether a specified map is adaptable 4396     * to a primitive map with byte keys and byte values. For a 4397     * map to be adaptable it can only contain 4398     * keys of class {@link Byte Byte}, 4399     * values of class {@link Byte Byte}, 4400     * and no <tt>null</tt> keys or <tt>null</tt> values. 4401     * 4402     * @param map 4403     * the map to examine. 4404     * 4405     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4406     * {@link ByteKeyByteMap ByteKeyByteMap}; 4407     * returns <tt>false</tt> otherwise. 4408     * 4409     * @throws NullPointerException 4410     * if <tt>map</tt> is <tt>null</tt>. 4411     * 4412     * @see #asByteKeyBytes(Map) 4413     */ 4414    public static boolean isByteKeyByteAdaptable(Map map) 4415    { return isByteAdaptable(map.keySet()) && isByteAdaptable(map.values()); } 4416     4417    /** 4418     * Indicates whether a specified map is adaptable 4419     * to a primitive map with byte keys and short values. For a 4420     * map to be adaptable it can only contain 4421     * keys of class {@link Byte Byte}, 4422     * values of class {@link Short Short}, 4423     * and no <tt>null</tt> keys or <tt>null</tt> values. 4424     * 4425     * @param map 4426     * the map to examine. 4427     * 4428     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4429     * {@link ByteKeyShortMap ByteKeyShortMap}; 4430     * returns <tt>false</tt> otherwise. 4431     * 4432     * @throws NullPointerException 4433     * if <tt>map</tt> is <tt>null</tt>. 4434     * 4435     * @see #asByteKeyShorts(Map) 4436     */ 4437    public static boolean isByteKeyShortAdaptable(Map map) 4438    { return isByteAdaptable(map.keySet()) && isShortAdaptable(map.values()); } 4439     4440    /** 4441     * Indicates whether a specified map is adaptable 4442     * to a primitive map with byte keys and int values. For a 4443     * map to be adaptable it can only contain 4444     * keys of class {@link Byte Byte}, 4445     * values of class {@link Integer Integer}, 4446     * and no <tt>null</tt> keys or <tt>null</tt> values. 4447     * 4448     * @param map 4449     * the map to examine. 4450     * 4451     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4452     * {@link ByteKeyIntMap ByteKeyIntMap}; 4453     * returns <tt>false</tt> otherwise. 4454     * 4455     * @throws NullPointerException 4456     * if <tt>map</tt> is <tt>null</tt>. 4457     * 4458     * @see #asByteKeyInts(Map) 4459     */ 4460    public static boolean isByteKeyIntAdaptable(Map map) 4461    { return isByteAdaptable(map.keySet()) && isIntAdaptable(map.values()); } 4462     4463    /** 4464     * Indicates whether a specified map is adaptable 4465     * to a primitive map with byte keys and long values. For a 4466     * map to be adaptable it can only contain 4467     * keys of class {@link Byte Byte}, 4468     * values of class {@link Long Long}, 4469     * and no <tt>null</tt> keys or <tt>null</tt> values. 4470     * 4471     * @param map 4472     * the map to examine. 4473     * 4474     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4475     * {@link ByteKeyLongMap ByteKeyLongMap}; 4476     * returns <tt>false</tt> otherwise. 4477     * 4478     * @throws NullPointerException 4479     * if <tt>map</tt> is <tt>null</tt>. 4480     * 4481     * @see #asByteKeyLongs(Map) 4482     */ 4483    public static boolean isByteKeyLongAdaptable(Map map) 4484    { return isByteAdaptable(map.keySet()) && isLongAdaptable(map.values()); } 4485     4486    /** 4487     * Indicates whether a specified map is adaptable 4488     * to a primitive map with byte keys and float values. For a 4489     * map to be adaptable it can only contain 4490     * keys of class {@link Byte Byte}, 4491     * values of class {@link Float Float}, 4492     * and no <tt>null</tt> keys or <tt>null</tt> values. 4493     * 4494     * @param map 4495     * the map to examine. 4496     * 4497     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4498     * {@link ByteKeyFloatMap ByteKeyFloatMap}; 4499     * returns <tt>false</tt> otherwise. 4500     * 4501     * @throws NullPointerException 4502     * if <tt>map</tt> is <tt>null</tt>. 4503     * 4504     * @see #asByteKeyFloats(Map) 4505     */ 4506    public static boolean isByteKeyFloatAdaptable(Map map) 4507    { return isByteAdaptable(map.keySet()) && isFloatAdaptable(map.values()); } 4508     4509    /** 4510     * Indicates whether a specified map is adaptable 4511     * to a primitive map with byte keys and double values. For a 4512     * map to be adaptable it can only contain 4513     * keys of class {@link Byte Byte}, 4514     * values of class {@link Double Double}, 4515     * and no <tt>null</tt> keys or <tt>null</tt> values. 4516     * 4517     * @param map 4518     * the map to examine. 4519     * 4520     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4521     * {@link ByteKeyDoubleMap ByteKeyDoubleMap}; 4522     * returns <tt>false</tt> otherwise. 4523     * 4524     * @throws NullPointerException 4525     * if <tt>map</tt> is <tt>null</tt>. 4526     * 4527     * @see #asByteKeyDoubles(Map) 4528     */ 4529    public static boolean isByteKeyDoubleAdaptable(Map map) 4530    { return isByteAdaptable(map.keySet()) && isDoubleAdaptable(map.values()); } 4531     4532    /** 4533     * Indicates whether a specified map is adaptable 4534     * to a primitive map with short keys and boolean values. For a 4535     * map to be adaptable it can only contain 4536     * keys of class {@link Short Short}, 4537     * values of class {@link Boolean Boolean}, 4538     * and no <tt>null</tt> keys or <tt>null</tt> values. 4539     * 4540     * @param map 4541     * the map to examine. 4542     * 4543     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4544     * {@link ShortKeyBooleanMap ShortKeyBooleanMap}; 4545     * returns <tt>false</tt> otherwise. 4546     * 4547     * @throws NullPointerException 4548     * if <tt>map</tt> is <tt>null</tt>. 4549     * 4550     * @see #asShortKeyBooleans(Map) 4551     */ 4552    public static boolean isShortKeyBooleanAdaptable(Map map) 4553    { return isShortAdaptable(map.keySet()) && isBooleanAdaptable(map.values()); } 4554     4555    /** 4556     * Indicates whether a specified map is adaptable 4557     * to a primitive map with short keys and char values. For a 4558     * map to be adaptable it can only contain 4559     * keys of class {@link Short Short}, 4560     * values of class {@link Character Character}, 4561     * and no <tt>null</tt> keys or <tt>null</tt> values. 4562     * 4563     * @param map 4564     * the map to examine. 4565     * 4566     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4567     * {@link ShortKeyCharMap ShortKeyCharMap}; 4568     * returns <tt>false</tt> otherwise. 4569     * 4570     * @throws NullPointerException 4571     * if <tt>map</tt> is <tt>null</tt>. 4572     * 4573     * @see #asShortKeyChars(Map) 4574     */ 4575    public static boolean isShortKeyCharAdaptable(Map map) 4576    { return isShortAdaptable(map.keySet()) && isCharAdaptable(map.values()); } 4577     4578    /** 4579     * Indicates whether a specified map is adaptable 4580     * to a primitive map with short keys and byte values. For a 4581     * map to be adaptable it can only contain 4582     * keys of class {@link Short Short}, 4583     * values of class {@link Byte Byte}, 4584     * and no <tt>null</tt> keys or <tt>null</tt> values. 4585     * 4586     * @param map 4587     * the map to examine. 4588     * 4589     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4590     * {@link ShortKeyByteMap ShortKeyByteMap}; 4591     * returns <tt>false</tt> otherwise. 4592     * 4593     * @throws NullPointerException 4594     * if <tt>map</tt> is <tt>null</tt>. 4595     * 4596     * @see #asShortKeyBytes(Map) 4597     */ 4598    public static boolean isShortKeyByteAdaptable(Map map) 4599    { return isShortAdaptable(map.keySet()) && isByteAdaptable(map.values()); } 4600     4601    /** 4602     * Indicates whether a specified map is adaptable 4603     * to a primitive map with short keys and short values. For a 4604     * map to be adaptable it can only contain 4605     * keys of class {@link Short Short}, 4606     * values of class {@link Short Short}, 4607     * and no <tt>null</tt> keys or <tt>null</tt> values. 4608     * 4609     * @param map 4610     * the map to examine. 4611     * 4612     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4613     * {@link ShortKeyShortMap ShortKeyShortMap}; 4614     * returns <tt>false</tt> otherwise. 4615     * 4616     * @throws NullPointerException 4617     * if <tt>map</tt> is <tt>null</tt>. 4618     * 4619     * @see #asShortKeyShorts(Map) 4620     */ 4621    public static boolean isShortKeyShortAdaptable(Map map) 4622    { return isShortAdaptable(map.keySet()) && isShortAdaptable(map.values()); } 4623     4624    /** 4625     * Indicates whether a specified map is adaptable 4626     * to a primitive map with short keys and int values. For a 4627     * map to be adaptable it can only contain 4628     * keys of class {@link Short Short}, 4629     * values of class {@link Integer Integer}, 4630     * and no <tt>null</tt> keys or <tt>null</tt> values. 4631     * 4632     * @param map 4633     * the map to examine. 4634     * 4635     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4636     * {@link ShortKeyIntMap ShortKeyIntMap}; 4637     * returns <tt>false</tt> otherwise. 4638     * 4639     * @throws NullPointerException 4640     * if <tt>map</tt> is <tt>null</tt>. 4641     * 4642     * @see #asShortKeyInts(Map) 4643     */ 4644    public static boolean isShortKeyIntAdaptable(Map map) 4645    { return isShortAdaptable(map.keySet()) && isIntAdaptable(map.values()); } 4646     4647    /** 4648     * Indicates whether a specified map is adaptable 4649     * to a primitive map with short keys and long values. For a 4650     * map to be adaptable it can only contain 4651     * keys of class {@link Short Short}, 4652     * values of class {@link Long Long}, 4653     * and no <tt>null</tt> keys or <tt>null</tt> values. 4654     * 4655     * @param map 4656     * the map to examine. 4657     * 4658     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4659     * {@link ShortKeyLongMap ShortKeyLongMap}; 4660     * returns <tt>false</tt> otherwise. 4661     * 4662     * @throws NullPointerException 4663     * if <tt>map</tt> is <tt>null</tt>. 4664     * 4665     * @see #asShortKeyLongs(Map) 4666     */ 4667    public static boolean isShortKeyLongAdaptable(Map map) 4668    { return isShortAdaptable(map.keySet()) && isLongAdaptable(map.values()); } 4669     4670    /** 4671     * Indicates whether a specified map is adaptable 4672     * to a primitive map with short keys and float values. For a 4673     * map to be adaptable it can only contain 4674     * keys of class {@link Short Short}, 4675     * values of class {@link Float Float}, 4676     * and no <tt>null</tt> keys or <tt>null</tt> values. 4677     * 4678     * @param map 4679     * the map to examine. 4680     * 4681     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4682     * {@link ShortKeyFloatMap ShortKeyFloatMap}; 4683     * returns <tt>false</tt> otherwise. 4684     * 4685     * @throws NullPointerException 4686     * if <tt>map</tt> is <tt>null</tt>. 4687     * 4688     * @see #asShortKeyFloats(Map) 4689     */ 4690    public static boolean isShortKeyFloatAdaptable(Map map) 4691    { return isShortAdaptable(map.keySet()) && isFloatAdaptable(map.values()); } 4692     4693    /** 4694     * Indicates whether a specified map is adaptable 4695     * to a primitive map with short keys and double values. For a 4696     * map to be adaptable it can only contain 4697     * keys of class {@link Short Short}, 4698     * values of class {@link Double Double}, 4699     * and no <tt>null</tt> keys or <tt>null</tt> values. 4700     * 4701     * @param map 4702     * the map to examine. 4703     * 4704     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4705     * {@link ShortKeyDoubleMap ShortKeyDoubleMap}; 4706     * returns <tt>false</tt> otherwise. 4707     * 4708     * @throws NullPointerException 4709     * if <tt>map</tt> is <tt>null</tt>. 4710     * 4711     * @see #asShortKeyDoubles(Map) 4712     */ 4713    public static boolean isShortKeyDoubleAdaptable(Map map) 4714    { return isShortAdaptable(map.keySet()) && isDoubleAdaptable(map.values()); } 4715     4716    /** 4717     * Indicates whether a specified map is adaptable 4718     * to a primitive map with int keys and boolean values. For a 4719     * map to be adaptable it can only contain 4720     * keys of class {@link Integer Integer}, 4721     * values of class {@link Boolean Boolean}, 4722     * and no <tt>null</tt> keys or <tt>null</tt> values. 4723     * 4724     * @param map 4725     * the map to examine. 4726     * 4727     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4728     * {@link IntKeyBooleanMap IntKeyBooleanMap}; 4729     * returns <tt>false</tt> otherwise. 4730     * 4731     * @throws NullPointerException 4732     * if <tt>map</tt> is <tt>null</tt>. 4733     * 4734     * @see #asIntKeyBooleans(Map) 4735     */ 4736    public static boolean isIntKeyBooleanAdaptable(Map map) 4737    { return isIntAdaptable(map.keySet()) && isBooleanAdaptable(map.values()); } 4738     4739    /** 4740     * Indicates whether a specified map is adaptable 4741     * to a primitive map with int keys and char values. For a 4742     * map to be adaptable it can only contain 4743     * keys of class {@link Integer Integer}, 4744     * values of class {@link Character Character}, 4745     * and no <tt>null</tt> keys or <tt>null</tt> values. 4746     * 4747     * @param map 4748     * the map to examine. 4749     * 4750     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4751     * {@link IntKeyCharMap IntKeyCharMap}; 4752     * returns <tt>false</tt> otherwise. 4753     * 4754     * @throws NullPointerException 4755     * if <tt>map</tt> is <tt>null</tt>. 4756     * 4757     * @see #asIntKeyChars(Map) 4758     */ 4759    public static boolean isIntKeyCharAdaptable(Map map) 4760    { return isIntAdaptable(map.keySet()) && isCharAdaptable(map.values()); } 4761     4762    /** 4763     * Indicates whether a specified map is adaptable 4764     * to a primitive map with int keys and byte values. For a 4765     * map to be adaptable it can only contain 4766     * keys of class {@link Integer Integer}, 4767     * values of class {@link Byte Byte}, 4768     * and no <tt>null</tt> keys or <tt>null</tt> values. 4769     * 4770     * @param map 4771     * the map to examine. 4772     * 4773     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4774     * {@link IntKeyByteMap IntKeyByteMap}; 4775     * returns <tt>false</tt> otherwise. 4776     * 4777     * @throws NullPointerException 4778     * if <tt>map</tt> is <tt>null</tt>. 4779     * 4780     * @see #asIntKeyBytes(Map) 4781     */ 4782    public static boolean isIntKeyByteAdaptable(Map map) 4783    { return isIntAdaptable(map.keySet()) && isByteAdaptable(map.values()); } 4784     4785    /** 4786     * Indicates whether a specified map is adaptable 4787     * to a primitive map with int keys and short values. For a 4788     * map to be adaptable it can only contain 4789     * keys of class {@link Integer Integer}, 4790     * values of class {@link Short Short}, 4791     * and no <tt>null</tt> keys or <tt>null</tt> values. 4792     * 4793     * @param map 4794     * the map to examine. 4795     * 4796     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4797     * {@link IntKeyShortMap IntKeyShortMap}; 4798     * returns <tt>false</tt> otherwise. 4799     * 4800     * @throws NullPointerException 4801     * if <tt>map</tt> is <tt>null</tt>. 4802     * 4803     * @see #asIntKeyShorts(Map) 4804     */ 4805    public static boolean isIntKeyShortAdaptable(Map map) 4806    { return isIntAdaptable(map.keySet()) && isShortAdaptable(map.values()); } 4807     4808    /** 4809     * Indicates whether a specified map is adaptable 4810     * to a primitive map with int keys and int values. For a 4811     * map to be adaptable it can only contain 4812     * keys of class {@link Integer Integer}, 4813     * values of class {@link Integer Integer}, 4814     * and no <tt>null</tt> keys or <tt>null</tt> values. 4815     * 4816     * @param map 4817     * the map to examine. 4818     * 4819     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4820     * {@link IntKeyIntMap IntKeyIntMap}; 4821     * returns <tt>false</tt> otherwise. 4822     * 4823     * @throws NullPointerException 4824     * if <tt>map</tt> is <tt>null</tt>. 4825     * 4826     * @see #asIntKeyInts(Map) 4827     */ 4828    public static boolean isIntKeyIntAdaptable(Map map) 4829    { return isIntAdaptable(map.keySet()) && isIntAdaptable(map.values()); } 4830     4831    /** 4832     * Indicates whether a specified map is adaptable 4833     * to a primitive map with int keys and long values. For a 4834     * map to be adaptable it can only contain 4835     * keys of class {@link Integer Integer}, 4836     * values of class {@link Long Long}, 4837     * and no <tt>null</tt> keys or <tt>null</tt> values. 4838     * 4839     * @param map 4840     * the map to examine. 4841     * 4842     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4843     * {@link IntKeyLongMap IntKeyLongMap}; 4844     * returns <tt>false</tt> otherwise. 4845     * 4846     * @throws NullPointerException 4847     * if <tt>map</tt> is <tt>null</tt>. 4848     * 4849     * @see #asIntKeyLongs(Map) 4850     */ 4851    public static boolean isIntKeyLongAdaptable(Map map) 4852    { return isIntAdaptable(map.keySet()) && isLongAdaptable(map.values()); } 4853     4854    /** 4855     * Indicates whether a specified map is adaptable 4856     * to a primitive map with int keys and float values. For a 4857     * map to be adaptable it can only contain 4858     * keys of class {@link Integer Integer}, 4859     * values of class {@link Float Float}, 4860     * and no <tt>null</tt> keys or <tt>null</tt> values. 4861     * 4862     * @param map 4863     * the map to examine. 4864     * 4865     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4866     * {@link IntKeyFloatMap IntKeyFloatMap}; 4867     * returns <tt>false</tt> otherwise. 4868     * 4869     * @throws NullPointerException 4870     * if <tt>map</tt> is <tt>null</tt>. 4871     * 4872     * @see #asIntKeyFloats(Map) 4873     */ 4874    public static boolean isIntKeyFloatAdaptable(Map map) 4875    { return isIntAdaptable(map.keySet()) && isFloatAdaptable(map.values()); } 4876     4877    /** 4878     * Indicates whether a specified map is adaptable 4879     * to a primitive map with int keys and double values. For a 4880     * map to be adaptable it can only contain 4881     * keys of class {@link Integer Integer}, 4882     * values of class {@link Double Double}, 4883     * and no <tt>null</tt> keys or <tt>null</tt> values. 4884     * 4885     * @param map 4886     * the map to examine. 4887     * 4888     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4889     * {@link IntKeyDoubleMap IntKeyDoubleMap}; 4890     * returns <tt>false</tt> otherwise. 4891     * 4892     * @throws NullPointerException 4893     * if <tt>map</tt> is <tt>null</tt>. 4894     * 4895     * @see #asIntKeyDoubles(Map) 4896     */ 4897    public static boolean isIntKeyDoubleAdaptable(Map map) 4898    { return isIntAdaptable(map.keySet()) && isDoubleAdaptable(map.values()); } 4899     4900    /** 4901     * Indicates whether a specified map is adaptable 4902     * to a primitive map with long keys and boolean values. For a 4903     * map to be adaptable it can only contain 4904     * keys of class {@link Long Long}, 4905     * values of class {@link Boolean Boolean}, 4906     * and no <tt>null</tt> keys or <tt>null</tt> values. 4907     * 4908     * @param map 4909     * the map to examine. 4910     * 4911     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4912     * {@link LongKeyBooleanMap LongKeyBooleanMap}; 4913     * returns <tt>false</tt> otherwise. 4914     * 4915     * @throws NullPointerException 4916     * if <tt>map</tt> is <tt>null</tt>. 4917     * 4918     * @see #asLongKeyBooleans(Map) 4919     */ 4920    public static boolean isLongKeyBooleanAdaptable(Map map) 4921    { return isLongAdaptable(map.keySet()) && isBooleanAdaptable(map.values()); } 4922     4923    /** 4924     * Indicates whether a specified map is adaptable 4925     * to a primitive map with long keys and char values. For a 4926     * map to be adaptable it can only contain 4927     * keys of class {@link Long Long}, 4928     * values of class {@link Character Character}, 4929     * and no <tt>null</tt> keys or <tt>null</tt> values. 4930     * 4931     * @param map 4932     * the map to examine. 4933     * 4934     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4935     * {@link LongKeyCharMap LongKeyCharMap}; 4936     * returns <tt>false</tt> otherwise. 4937     * 4938     * @throws NullPointerException 4939     * if <tt>map</tt> is <tt>null</tt>. 4940     * 4941     * @see #asLongKeyChars(Map) 4942     */ 4943    public static boolean isLongKeyCharAdaptable(Map map) 4944    { return isLongAdaptable(map.keySet()) && isCharAdaptable(map.values()); } 4945     4946    /** 4947     * Indicates whether a specified map is adaptable 4948     * to a primitive map with long keys and byte values. For a 4949     * map to be adaptable it can only contain 4950     * keys of class {@link Long Long}, 4951     * values of class {@link Byte Byte}, 4952     * and no <tt>null</tt> keys or <tt>null</tt> values. 4953     * 4954     * @param map 4955     * the map to examine. 4956     * 4957     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4958     * {@link LongKeyByteMap LongKeyByteMap}; 4959     * returns <tt>false</tt> otherwise. 4960     * 4961     * @throws NullPointerException 4962     * if <tt>map</tt> is <tt>null</tt>. 4963     * 4964     * @see #asLongKeyBytes(Map) 4965     */ 4966    public static boolean isLongKeyByteAdaptable(Map map) 4967    { return isLongAdaptable(map.keySet()) && isByteAdaptable(map.values()); } 4968     4969    /** 4970     * Indicates whether a specified map is adaptable 4971     * to a primitive map with long keys and short values. For a 4972     * map to be adaptable it can only contain 4973     * keys of class {@link Long Long}, 4974     * values of class {@link Short Short}, 4975     * and no <tt>null</tt> keys or <tt>null</tt> values. 4976     * 4977     * @param map 4978     * the map to examine. 4979     * 4980     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 4981     * {@link LongKeyShortMap LongKeyShortMap}; 4982     * returns <tt>false</tt> otherwise. 4983     * 4984     * @throws NullPointerException 4985     * if <tt>map</tt> is <tt>null</tt>. 4986     * 4987     * @see #asLongKeyShorts(Map) 4988     */ 4989    public static boolean isLongKeyShortAdaptable(Map map) 4990    { return isLongAdaptable(map.keySet()) && isShortAdaptable(map.values()); } 4991     4992    /** 4993     * Indicates whether a specified map is adaptable 4994     * to a primitive map with long keys and int values. For a 4995     * map to be adaptable it can only contain 4996     * keys of class {@link Long Long}, 4997     * values of class {@link Integer Integer}, 4998     * and no <tt>null</tt> keys or <tt>null</tt> values. 4999     * 5000     * @param map 5001     * the map to examine. 5002     * 5003     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5004     * {@link LongKeyIntMap LongKeyIntMap}; 5005     * returns <tt>false</tt> otherwise. 5006     * 5007     * @throws NullPointerException 5008     * if <tt>map</tt> is <tt>null</tt>. 5009     * 5010     * @see #asLongKeyInts(Map) 5011     */ 5012    public static boolean isLongKeyIntAdaptable(Map map) 5013    { return isLongAdaptable(map.keySet()) && isIntAdaptable(map.values()); } 5014     5015    /** 5016     * Indicates whether a specified map is adaptable 5017     * to a primitive map with long keys and long values. For a 5018     * map to be adaptable it can only contain 5019     * keys of class {@link Long Long}, 5020     * values of class {@link Long Long}, 5021     * and no <tt>null</tt> keys or <tt>null</tt> values. 5022     * 5023     * @param map 5024     * the map to examine. 5025     * 5026     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5027     * {@link LongKeyLongMap LongKeyLongMap}; 5028     * returns <tt>false</tt> otherwise. 5029     * 5030     * @throws NullPointerException 5031     * if <tt>map</tt> is <tt>null</tt>. 5032     * 5033     * @see #asLongKeyLongs(Map) 5034     */ 5035    public static boolean isLongKeyLongAdaptable(Map map) 5036    { return isLongAdaptable(map.keySet()) && isLongAdaptable(map.values()); } 5037     5038    /** 5039     * Indicates whether a specified map is adaptable 5040     * to a primitive map with long keys and float values. For a 5041     * map to be adaptable it can only contain 5042     * keys of class {@link Long Long}, 5043     * values of class {@link Float Float}, 5044     * and no <tt>null</tt> keys or <tt>null</tt> values. 5045     * 5046     * @param map 5047     * the map to examine. 5048     * 5049     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5050     * {@link LongKeyFloatMap LongKeyFloatMap}; 5051     * returns <tt>false</tt> otherwise. 5052     * 5053     * @throws NullPointerException 5054     * if <tt>map</tt> is <tt>null</tt>. 5055     * 5056     * @see #asLongKeyFloats(Map) 5057     */ 5058    public static boolean isLongKeyFloatAdaptable(Map map) 5059    { return isLongAdaptable(map.keySet()) && isFloatAdaptable(map.values()); } 5060     5061    /** 5062     * Indicates whether a specified map is adaptable 5063     * to a primitive map with long keys and double values. For a 5064     * map to be adaptable it can only contain 5065     * keys of class {@link Long Long}, 5066     * values of class {@link Double Double}, 5067     * and no <tt>null</tt> keys or <tt>null</tt> values. 5068     * 5069     * @param map 5070     * the map to examine. 5071     * 5072     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5073     * {@link LongKeyDoubleMap LongKeyDoubleMap}; 5074     * returns <tt>false</tt> otherwise. 5075     * 5076     * @throws NullPointerException 5077     * if <tt>map</tt> is <tt>null</tt>. 5078     * 5079     * @see #asLongKeyDoubles(Map) 5080     */ 5081    public static boolean isLongKeyDoubleAdaptable(Map map) 5082    { return isLongAdaptable(map.keySet()) && isDoubleAdaptable(map.values()); } 5083     5084    /** 5085     * Indicates whether a specified map is adaptable 5086     * to a primitive map with float keys and boolean values. For a 5087     * map to be adaptable it can only contain 5088     * keys of class {@link Float Float}, 5089     * values of class {@link Boolean Boolean}, 5090     * and no <tt>null</tt> keys or <tt>null</tt> values. 5091     * 5092     * @param map 5093     * the map to examine. 5094     * 5095     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5096     * {@link FloatKeyBooleanMap FloatKeyBooleanMap}; 5097     * returns <tt>false</tt> otherwise. 5098     * 5099     * @throws NullPointerException 5100     * if <tt>map</tt> is <tt>null</tt>. 5101     * 5102     * @see #asFloatKeyBooleans(Map) 5103     */ 5104    public static boolean isFloatKeyBooleanAdaptable(Map map) 5105    { return isFloatAdaptable(map.keySet()) && isBooleanAdaptable(map.values()); } 5106     5107    /** 5108     * Indicates whether a specified map is adaptable 5109     * to a primitive map with float keys and char values. For a 5110     * map to be adaptable it can only contain 5111     * keys of class {@link Float Float}, 5112     * values of class {@link Character Character}, 5113     * and no <tt>null</tt> keys or <tt>null</tt> values. 5114     * 5115     * @param map 5116     * the map to examine. 5117     * 5118     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5119     * {@link FloatKeyCharMap FloatKeyCharMap}; 5120     * returns <tt>false</tt> otherwise. 5121     * 5122     * @throws NullPointerException 5123     * if <tt>map</tt> is <tt>null</tt>. 5124     * 5125     * @see #asFloatKeyChars(Map) 5126     */ 5127    public static boolean isFloatKeyCharAdaptable(Map map) 5128    { return isFloatAdaptable(map.keySet()) && isCharAdaptable(map.values()); } 5129     5130    /** 5131     * Indicates whether a specified map is adaptable 5132     * to a primitive map with float keys and byte values. For a 5133     * map to be adaptable it can only contain 5134     * keys of class {@link Float Float}, 5135     * values of class {@link Byte Byte}, 5136     * and no <tt>null</tt> keys or <tt>null</tt> values. 5137     * 5138     * @param map 5139     * the map to examine. 5140     * 5141     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5142     * {@link FloatKeyByteMap FloatKeyByteMap}; 5143     * returns <tt>false</tt> otherwise. 5144     * 5145     * @throws NullPointerException 5146     * if <tt>map</tt> is <tt>null</tt>. 5147     * 5148     * @see #asFloatKeyBytes(Map) 5149     */ 5150    public static boolean isFloatKeyByteAdaptable(Map map) 5151    { return isFloatAdaptable(map.keySet()) && isByteAdaptable(map.values()); } 5152     5153    /** 5154     * Indicates whether a specified map is adaptable 5155     * to a primitive map with float keys and short values. For a 5156     * map to be adaptable it can only contain 5157     * keys of class {@link Float Float}, 5158     * values of class {@link Short Short}, 5159     * and no <tt>null</tt> keys or <tt>null</tt> values. 5160     * 5161     * @param map 5162     * the map to examine. 5163     * 5164     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5165     * {@link FloatKeyShortMap FloatKeyShortMap}; 5166     * returns <tt>false</tt> otherwise. 5167     * 5168     * @throws NullPointerException 5169     * if <tt>map</tt> is <tt>null</tt>. 5170     * 5171     * @see #asFloatKeyShorts(Map) 5172     */ 5173    public static boolean isFloatKeyShortAdaptable(Map map) 5174    { return isFloatAdaptable(map.keySet()) && isShortAdaptable(map.values()); } 5175     5176    /** 5177     * Indicates whether a specified map is adaptable 5178     * to a primitive map with float keys and int values. For a 5179     * map to be adaptable it can only contain 5180     * keys of class {@link Float Float}, 5181     * values of class {@link Integer Integer}, 5182     * and no <tt>null</tt> keys or <tt>null</tt> values. 5183     * 5184     * @param map 5185     * the map to examine. 5186     * 5187     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5188     * {@link FloatKeyIntMap FloatKeyIntMap}; 5189     * returns <tt>false</tt> otherwise. 5190     * 5191     * @throws NullPointerException 5192     * if <tt>map</tt> is <tt>null</tt>. 5193     * 5194     * @see #asFloatKeyInts(Map) 5195     */ 5196    public static boolean isFloatKeyIntAdaptable(Map map) 5197    { return isFloatAdaptable(map.keySet()) && isIntAdaptable(map.values()); } 5198     5199    /** 5200     * Indicates whether a specified map is adaptable 5201     * to a primitive map with float keys and long values. For a 5202     * map to be adaptable it can only contain 5203     * keys of class {@link Float Float}, 5204     * values of class {@link Long Long}, 5205     * and no <tt>null</tt> keys or <tt>null</tt> values. 5206     * 5207     * @param map 5208     * the map to examine. 5209     * 5210     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5211     * {@link FloatKeyLongMap FloatKeyLongMap}; 5212     * returns <tt>false</tt> otherwise. 5213     * 5214     * @throws NullPointerException 5215     * if <tt>map</tt> is <tt>null</tt>. 5216     * 5217     * @see #asFloatKeyLongs(Map) 5218     */ 5219    public static boolean isFloatKeyLongAdaptable(Map map) 5220    { return isFloatAdaptable(map.keySet()) && isLongAdaptable(map.values()); } 5221     5222    /** 5223     * Indicates whether a specified map is adaptable 5224     * to a primitive map with float keys and float values. For a 5225     * map to be adaptable it can only contain 5226     * keys of class {@link Float Float}, 5227     * values of class {@link Float Float}, 5228     * and no <tt>null</tt> keys or <tt>null</tt> values. 5229     * 5230     * @param map 5231     * the map to examine. 5232     * 5233     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5234     * {@link FloatKeyFloatMap FloatKeyFloatMap}; 5235     * returns <tt>false</tt> otherwise. 5236     * 5237     * @throws NullPointerException 5238     * if <tt>map</tt> is <tt>null</tt>. 5239     * 5240     * @see #asFloatKeyFloats(Map) 5241     */ 5242    public static boolean isFloatKeyFloatAdaptable(Map map) 5243    { return isFloatAdaptable(map.keySet()) && isFloatAdaptable(map.values()); } 5244     5245    /** 5246     * Indicates whether a specified map is adaptable 5247     * to a primitive map with float keys and double values. For a 5248     * map to be adaptable it can only contain 5249     * keys of class {@link Float Float}, 5250     * values of class {@link Double Double}, 5251     * and no <tt>null</tt> keys or <tt>null</tt> values. 5252     * 5253     * @param map 5254     * the map to examine. 5255     * 5256     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5257     * {@link FloatKeyDoubleMap FloatKeyDoubleMap}; 5258     * returns <tt>false</tt> otherwise. 5259     * 5260     * @throws NullPointerException 5261     * if <tt>map</tt> is <tt>null</tt>. 5262     * 5263     * @see #asFloatKeyDoubles(Map) 5264     */ 5265    public static boolean isFloatKeyDoubleAdaptable(Map map) 5266    { return isFloatAdaptable(map.keySet()) && isDoubleAdaptable(map.values()); } 5267     5268    /** 5269     * Indicates whether a specified map is adaptable 5270     * to a primitive map with double keys and boolean values. For a 5271     * map to be adaptable it can only contain 5272     * keys of class {@link Double Double}, 5273     * values of class {@link Boolean Boolean}, 5274     * and no <tt>null</tt> keys or <tt>null</tt> values. 5275     * 5276     * @param map 5277     * the map to examine. 5278     * 5279     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5280     * {@link DoubleKeyBooleanMap DoubleKeyBooleanMap}; 5281     * returns <tt>false</tt> otherwise. 5282     * 5283     * @throws NullPointerException 5284     * if <tt>map</tt> is <tt>null</tt>. 5285     * 5286     * @see #asDoubleKeyBooleans(Map) 5287     */ 5288    public static boolean isDoubleKeyBooleanAdaptable(Map map) 5289    { return isDoubleAdaptable(map.keySet()) && isBooleanAdaptable(map.values()); } 5290     5291    /** 5292     * Indicates whether a specified map is adaptable 5293     * to a primitive map with double keys and char values. For a 5294     * map to be adaptable it can only contain 5295     * keys of class {@link Double Double}, 5296     * values of class {@link Character Character}, 5297     * and no <tt>null</tt> keys or <tt>null</tt> values. 5298     * 5299     * @param map 5300     * the map to examine. 5301     * 5302     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5303     * {@link DoubleKeyCharMap DoubleKeyCharMap}; 5304     * returns <tt>false</tt> otherwise. 5305     * 5306     * @throws NullPointerException 5307     * if <tt>map</tt> is <tt>null</tt>. 5308     * 5309     * @see #asDoubleKeyChars(Map) 5310     */ 5311    public static boolean isDoubleKeyCharAdaptable(Map map) 5312    { return isDoubleAdaptable(map.keySet()) && isCharAdaptable(map.values()); } 5313     5314    /** 5315     * Indicates whether a specified map is adaptable 5316     * to a primitive map with double keys and byte values. For a 5317     * map to be adaptable it can only contain 5318     * keys of class {@link Double Double}, 5319     * values of class {@link Byte Byte}, 5320     * and no <tt>null</tt> keys or <tt>null</tt> values. 5321     * 5322     * @param map 5323     * the map to examine. 5324     * 5325     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5326     * {@link DoubleKeyByteMap DoubleKeyByteMap}; 5327     * returns <tt>false</tt> otherwise. 5328     * 5329     * @throws NullPointerException 5330     * if <tt>map</tt> is <tt>null</tt>. 5331     * 5332     * @see #asDoubleKeyBytes(Map) 5333     */ 5334    public static boolean isDoubleKeyByteAdaptable(Map map) 5335    { return isDoubleAdaptable(map.keySet()) && isByteAdaptable(map.values()); } 5336     5337    /** 5338     * Indicates whether a specified map is adaptable 5339     * to a primitive map with double keys and short values. For a 5340     * map to be adaptable it can only contain 5341     * keys of class {@link Double Double}, 5342     * values of class {@link Short Short}, 5343     * and no <tt>null</tt> keys or <tt>null</tt> values. 5344     * 5345     * @param map 5346     * the map to examine. 5347     * 5348     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5349     * {@link DoubleKeyShortMap DoubleKeyShortMap}; 5350     * returns <tt>false</tt> otherwise. 5351     * 5352     * @throws NullPointerException 5353     * if <tt>map</tt> is <tt>null</tt>. 5354     * 5355     * @see #asDoubleKeyShorts(Map) 5356     */ 5357    public static boolean isDoubleKeyShortAdaptable(Map map) 5358    { return isDoubleAdaptable(map.keySet()) && isShortAdaptable(map.values()); } 5359     5360    /** 5361     * Indicates whether a specified map is adaptable 5362     * to a primitive map with double keys and int values. For a 5363     * map to be adaptable it can only contain 5364     * keys of class {@link Double Double}, 5365     * values of class {@link Integer Integer}, 5366     * and no <tt>null</tt> keys or <tt>null</tt> values. 5367     * 5368     * @param map 5369     * the map to examine. 5370     * 5371     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5372     * {@link DoubleKeyIntMap DoubleKeyIntMap}; 5373     * returns <tt>false</tt> otherwise. 5374     * 5375     * @throws NullPointerException 5376     * if <tt>map</tt> is <tt>null</tt>. 5377     * 5378     * @see #asDoubleKeyInts(Map) 5379     */ 5380    public static boolean isDoubleKeyIntAdaptable(Map map) 5381    { return isDoubleAdaptable(map.keySet()) && isIntAdaptable(map.values()); } 5382     5383    /** 5384     * Indicates whether a specified map is adaptable 5385     * to a primitive map with double keys and long values. For a 5386     * map to be adaptable it can only contain 5387     * keys of class {@link Double Double}, 5388     * values of class {@link Long Long}, 5389     * and no <tt>null</tt> keys or <tt>null</tt> values. 5390     * 5391     * @param map 5392     * the map to examine. 5393     * 5394     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5395     * {@link DoubleKeyLongMap DoubleKeyLongMap}; 5396     * returns <tt>false</tt> otherwise. 5397     * 5398     * @throws NullPointerException 5399     * if <tt>map</tt> is <tt>null</tt>. 5400     * 5401     * @see #asDoubleKeyLongs(Map) 5402     */ 5403    public static boolean isDoubleKeyLongAdaptable(Map map) 5404    { return isDoubleAdaptable(map.keySet()) && isLongAdaptable(map.values()); } 5405     5406    /** 5407     * Indicates whether a specified map is adaptable 5408     * to a primitive map with double keys and float values. For a 5409     * map to be adaptable it can only contain 5410     * keys of class {@link Double Double}, 5411     * values of class {@link Float Float}, 5412     * and no <tt>null</tt> keys or <tt>null</tt> values. 5413     * 5414     * @param map 5415     * the map to examine. 5416     * 5417     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5418     * {@link DoubleKeyFloatMap DoubleKeyFloatMap}; 5419     * returns <tt>false</tt> otherwise. 5420     * 5421     * @throws NullPointerException 5422     * if <tt>map</tt> is <tt>null</tt>. 5423     * 5424     * @see #asDoubleKeyFloats(Map) 5425     */ 5426    public static boolean isDoubleKeyFloatAdaptable(Map map) 5427    { return isDoubleAdaptable(map.keySet()) && isFloatAdaptable(map.values()); } 5428     5429    /** 5430     * Indicates whether a specified map is adaptable 5431     * to a primitive map with double keys and double values. For a 5432     * map to be adaptable it can only contain 5433     * keys of class {@link Double Double}, 5434     * values of class {@link Double Double}, 5435     * and no <tt>null</tt> keys or <tt>null</tt> values. 5436     * 5437     * @param map 5438     * the map to examine. 5439     * 5440     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5441     * {@link DoubleKeyDoubleMap DoubleKeyDoubleMap}; 5442     * returns <tt>false</tt> otherwise. 5443     * 5444     * @throws NullPointerException 5445     * if <tt>map</tt> is <tt>null</tt>. 5446     * 5447     * @see #asDoubleKeyDoubles(Map) 5448     */ 5449    public static boolean isDoubleKeyDoubleAdaptable(Map map) 5450    { return isDoubleAdaptable(map.keySet()) && isDoubleAdaptable(map.values()); } 5451 5452    // --------------------------------------------------------------- 5453 // isObjectKeyTAdaptable(Map map) 5454 // --------------------------------------------------------------- 5455 5456    /** 5457     * Indicates whether a specified map is adaptable 5458     * to a primitive map with object keys and boolean values. For a 5459     * map to be adaptable it can only contain values of class 5460     * {@link Boolean Boolean} and no <tt>null</tt> values. 5461     * 5462     * @param map 5463     * the map to examine. 5464     * 5465     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5466     * {@link ObjectKeyBooleanMap ObjectKeyBooleanMap}; 5467     * returns false otherwise. 5468     * 5469     * @throws NullPointerException 5470     * if <tt>map</tt> is <tt>null</tt>. 5471     * 5472     * @since 1.1 5473     */ 5474    public static boolean isObjectKeyBooleanAdaptable(Map map) 5475    { return isBooleanAdaptable(map.values()); } 5476 5477    /** 5478     * Indicates whether a specified map is adaptable 5479     * to a primitive map with object keys and char values. For a 5480     * map to be adaptable it can only contain values of class 5481     * {@link Character Character} and no <tt>null</tt> values. 5482     * 5483     * @param map 5484     * the map to examine. 5485     * 5486     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5487     * {@link ObjectKeyCharMap ObjectKeyCharMap}; 5488     * returns false otherwise. 5489     * 5490     * @throws NullPointerException 5491     * if <tt>map</tt> is <tt>null</tt>. 5492     * 5493     * @since 1.1 5494     */ 5495    public static boolean isObjectKeyCharAdaptable(Map map) 5496    { return isCharAdaptable(map.values()); } 5497 5498    /** 5499     * Indicates whether a specified map is adaptable 5500     * to a primitive map with object keys and byte values. For a 5501     * map to be adaptable it can only contain values of class 5502     * {@link Byte Byte} and no <tt>null</tt> values. 5503     * 5504     * @param map 5505     * the map to examine. 5506     * 5507     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5508     * {@link ObjectKeyByteMap ObjectKeyByteMap}; 5509     * returns false otherwise. 5510     * 5511     * @throws NullPointerException 5512     * if <tt>map</tt> is <tt>null</tt>. 5513     * 5514     * @since 1.1 5515     */ 5516    public static boolean isObjectKeyByteAdaptable(Map map) 5517    { return isByteAdaptable(map.values()); } 5518 5519    /** 5520     * Indicates whether a specified map is adaptable 5521     * to a primitive map with object keys and short values. For a 5522     * map to be adaptable it can only contain values of class 5523     * {@link Short Short} and no <tt>null</tt> values. 5524     * 5525     * @param map 5526     * the map to examine. 5527     * 5528     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5529     * {@link ObjectKeyShortMap ObjectKeyShortMap}; 5530     * returns false otherwise. 5531     * 5532     * @throws NullPointerException 5533     * if <tt>map</tt> is <tt>null</tt>. 5534     * 5535     * @since 1.1 5536     */ 5537    public static boolean isObjectKeyShortAdaptable(Map map) 5538    { return isShortAdaptable(map.values()); } 5539 5540    /** 5541     * Indicates whether a specified map is adaptable 5542     * to a primitive map with object keys and int values. For a 5543     * map to be adaptable it can only contain values of class 5544     * {@link Integer Integer} and no <tt>null</tt> values. 5545     * 5546     * @param map 5547     * the map to examine. 5548     * 5549     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5550     * {@link ObjectKeyIntMap ObjectKeyIntMap}; 5551     * returns false otherwise. 5552     * 5553     * @throws NullPointerException 5554     * if <tt>map</tt> is <tt>null</tt>. 5555     * 5556     * @since 1.1 5557     */ 5558    public static boolean isObjectKeyIntAdaptable(Map map) 5559    { return isIntAdaptable(map.values()); } 5560 5561    /** 5562     * Indicates whether a specified map is adaptable 5563     * to a primitive map with object keys and long values. For a 5564     * map to be adaptable it can only contain values of class 5565     * {@link Long Long} and no <tt>null</tt> values. 5566     * 5567     * @param map 5568     * the map to examine. 5569     * 5570     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5571     * {@link ObjectKeyLongMap ObjectKeyLongMap}; 5572     * returns false otherwise. 5573     * 5574     * @throws NullPointerException 5575     * if <tt>map</tt> is <tt>null</tt>. 5576     * 5577     * @since 1.1 5578     */ 5579    public static boolean isObjectKeyLongAdaptable(Map map) 5580    { return isLongAdaptable(map.values()); } 5581 5582    /** 5583     * Indicates whether a specified map is adaptable 5584     * to a primitive map with object keys and float values. For a 5585     * map to be adaptable it can only contain values of class 5586     * {@link Float Float} and no <tt>null</tt> values. 5587     * 5588     * @param map 5589     * the map to examine. 5590     * 5591     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5592     * {@link ObjectKeyFloatMap ObjectKeyFloatMap}; 5593     * returns false otherwise. 5594     * 5595     * @throws NullPointerException 5596     * if <tt>map</tt> is <tt>null</tt>. 5597     * 5598     * @since 1.1 5599     */ 5600    public static boolean isObjectKeyFloatAdaptable(Map map) 5601    { return isFloatAdaptable(map.values()); } 5602 5603    /** 5604     * Indicates whether a specified map is adaptable 5605     * to a primitive map with object keys and double values. For a 5606     * map to be adaptable it can only contain values of class 5607     * {@link Double Double} and no <tt>null</tt> values. 5608     * 5609     * @param map 5610     * the map to examine. 5611     * 5612     * @return <tt>true</tt> if <tt>map</tt> is adaptable to a 5613     * {@link ObjectKeyDoubleMap ObjectKeyDoubleMap}; 5614     * returns false otherwise. 5615     * 5616     * @throws NullPointerException 5617     * if <tt>map</tt> is <tt>null</tt>. 5618     * 5619     * @since 1.1 5620     */ 5621    public static boolean isObjectKeyDoubleAdaptable(Map map) 5622    { return isDoubleAdaptable(map.values()); } 5623 5624} 5625

A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame Popular Tags