1 /*
   2  * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.awt.datatransfer;
  27 
  28 import java.awt.Toolkit;
  29 
  30 import java.lang.ref.SoftReference;
  31 
  32 import java.io.BufferedReader;
  33 import java.io.File;
  34 import java.io.InputStreamReader;
  35 import java.io.IOException;
  36 
  37 import java.net.URL;
  38 import java.net.MalformedURLException;
  39 
  40 import java.util.ArrayList;
  41 import java.util.HashMap;
  42 import java.util.HashSet;
  43 import java.util.Iterator;
  44 import java.util.LinkedHashSet;
  45 import java.util.List;
  46 import java.util.Map;
  47 import java.util.Set;
  48 import java.util.WeakHashMap;
  49 
  50 import sun.awt.datatransfer.DataTransferer;
  51 
  52 /**
  53  * The SystemFlavorMap is a configurable map between "natives" (Strings), which
  54  * correspond to platform-specific data formats, and "flavors" (DataFlavors),
  55  * which correspond to platform-independent MIME types. This mapping is used
  56  * by the data transfer subsystem to transfer data between Java and native
  57  * applications, and between Java applications in separate VMs.
  58  * <p>
  59  *
  60  * @since 1.2
  61  */
  62 public final class SystemFlavorMap implements FlavorMap, FlavorTable {
  63 
  64     /**
  65      * Constant prefix used to tag Java types converted to native platform
  66      * type.
  67      */
  68     private static String JavaMIME = "JAVA_DATAFLAVOR:";
  69 
  70     /**
  71      * System singleton which maps a thread's ClassLoader to a SystemFlavorMap.
  72      */
  73     private static final WeakHashMap<ClassLoader, FlavorMap> flavorMaps = new WeakHashMap<>();
  74 
  75     /**
  76      * Copied from java.util.Properties.
  77      */
  78     private static final String keyValueSeparators = "=: \t\r\n\f";
  79     private static final String strictKeyValueSeparators = "=:";
  80     private static final String whiteSpaceChars = " \t\r\n\f";
  81 
  82     /**
  83      * The list of valid, decoded text flavor representation classes, in order
  84      * from best to worst.
  85      */
  86     private static final String[] UNICODE_TEXT_CLASSES = {
  87         "java.io.Reader", "java.lang.String", "java.nio.CharBuffer", "\"[C\""
  88     };
  89 
  90     /**
  91      * The list of valid, encoded text flavor representation classes, in order
  92      * from best to worst.
  93      */
  94     private static final String[] ENCODED_TEXT_CLASSES = {
  95         "java.io.InputStream", "java.nio.ByteBuffer", "\"[B\""
  96     };
  97 
  98     /**
  99      * A String representing text/plain MIME type.
 100      */
 101     private static final String TEXT_PLAIN_BASE_TYPE = "text/plain";
 102 
 103     /**
 104      * A String representing text/html MIME type.
 105      */
 106     private static final String HTML_TEXT_BASE_TYPE = "text/html";
 107 
 108     /**
 109      * This constant is passed to flavorToNativeLookup() to indicate that a
 110      * a native should be synthesized, stored, and returned by encoding the
 111      * DataFlavor's MIME type in case if the DataFlavor is not found in
 112      * 'flavorToNative' map.
 113      */
 114     private static final boolean SYNTHESIZE_IF_NOT_FOUND = true;
 115 
 116     /**
 117      * Maps native Strings to Lists of DataFlavors (or base type Strings for
 118      * text DataFlavors).
 119      * Do not use the field directly, use getNativeToFlavor() instead.
 120      */
 121     private final Map<String, List<DataFlavor>> nativeToFlavor = new HashMap<>();
 122 
 123     /**
 124      * Accessor to nativeToFlavor map.  Since we use lazy initialization we must
 125      * use this accessor instead of direct access to the field which may not be
 126      * initialized yet.  This method will initialize the field if needed.
 127      *
 128      * @return nativeToFlavor
 129      */
 130     private Map<String, List<DataFlavor>> getNativeToFlavor() {
 131         if (!isMapInitialized) {
 132             initSystemFlavorMap();
 133         }
 134         return nativeToFlavor;
 135     }
 136 
 137     /**
 138      * Maps DataFlavors (or base type Strings for text DataFlavors) to Lists of
 139      * native Strings.
 140      * Do not use the field directly, use getFlavorToNative() instead.
 141      */
 142     private final Map<DataFlavor, List<String>> flavorToNative = new HashMap<>();
 143 
 144     /**
 145      * Accessor to flavorToNative map.  Since we use lazy initialization we must
 146      * use this accessor instead of direct access to the field which may not be
 147      * initialized yet.  This method will initialize the field if needed.
 148      *
 149      * @return flavorToNative
 150      */
 151     private synchronized Map<DataFlavor, List<String>> getFlavorToNative() {
 152         if (!isMapInitialized) {
 153             initSystemFlavorMap();
 154         }
 155         return flavorToNative;
 156     }
 157 
 158     /**
 159      * Shows if the object has been initialized.
 160      */
 161     private boolean isMapInitialized = false;
 162 
 163     /**
 164      * Caches the result of getNativesForFlavor(). Maps DataFlavors to
 165      * SoftReferences which reference Lists of String natives.
 166      */
 167     private Map<DataFlavor, SoftReference<List<String>>> getNativesForFlavorCache = new HashMap<>();
 168 
 169     /**
 170      * Caches the result getFlavorsForNative(). Maps String natives to
 171      * SoftReferences which reference Lists of DataFlavors.
 172      */
 173     private Map<String, SoftReference<List<DataFlavor>>> getFlavorsForNativeCache = new HashMap<>();
 174 
 175     /**
 176      * Dynamic mapping generation used for text mappings should not be applied
 177      * to the DataFlavors and String natives for which the mappings have been
 178      * explicitly specified with setFlavorsForNative() or
 179      * setNativesForFlavor(). This keeps all such keys.
 180      */
 181     private Set disabledMappingGenerationKeys = new HashSet();
 182 
 183     /**
 184      * Returns the default FlavorMap for this thread's ClassLoader.
 185      */
 186     public static FlavorMap getDefaultFlavorMap() {
 187         ClassLoader contextClassLoader =
 188             Thread.currentThread().getContextClassLoader();
 189         if (contextClassLoader == null) {
 190             contextClassLoader = ClassLoader.getSystemClassLoader();
 191         }
 192 
 193         FlavorMap fm;
 194 
 195         synchronized(flavorMaps) {
 196             fm = flavorMaps.get(contextClassLoader);
 197             if (fm == null) {
 198                 fm = new SystemFlavorMap();
 199                 flavorMaps.put(contextClassLoader, fm);
 200             }
 201         }
 202 
 203         return fm;
 204     }
 205 
 206     private SystemFlavorMap() {
 207     }
 208 
 209     /**
 210      * Initializes a SystemFlavorMap by reading flavormap.properties and
 211      * AWT.DnD.flavorMapFileURL.
 212      * For thread-safety must be called under lock on this.
 213      */
 214     private void initSystemFlavorMap() {
 215         if (isMapInitialized) {
 216             return;
 217         }
 218 
 219         isMapInitialized = true;
 220         BufferedReader flavormapDotProperties =
 221             java.security.AccessController.doPrivileged(
 222                 new java.security.PrivilegedAction<BufferedReader>() {
 223                     public BufferedReader run() {
 224                         String fileName =
 225                             System.getProperty("java.home") +
 226                             File.separator +
 227                             "lib" +
 228                             File.separator +
 229                             "flavormap.properties";
 230                         try {
 231                             return new BufferedReader
 232                                 (new InputStreamReader
 233                                     (new File(fileName).toURI().toURL().openStream(), "ISO-8859-1"));
 234                         } catch (MalformedURLException e) {
 235                             System.err.println("MalformedURLException:" + e + " while loading default flavormap.properties file:" + fileName);
 236                         } catch (IOException e) {
 237                             System.err.println("IOException:" + e + " while loading default flavormap.properties file:" + fileName);
 238                         }
 239                         return null;
 240                     }
 241                 });
 242 
 243         BufferedReader flavormapURL =
 244             java.security.AccessController.doPrivileged(
 245                 new java.security.PrivilegedAction<BufferedReader>() {
 246                     public BufferedReader run() {
 247                         String url = Toolkit.getProperty("AWT.DnD.flavorMapFileURL", null);
 248 
 249                         if (url == null) {
 250                             return null;
 251                         }
 252 
 253                         try {
 254                             return new BufferedReader
 255                                 (new InputStreamReader
 256                                     (new URL(url).openStream(), "ISO-8859-1"));
 257                         } catch (MalformedURLException e) {
 258                             System.err.println("MalformedURLException:" + e + " while reading AWT.DnD.flavorMapFileURL:" + url);
 259                         } catch (IOException e) {
 260                             System.err.println("IOException:" + e + " while reading AWT.DnD.flavorMapFileURL:" + url);
 261                         }
 262                         return null;
 263                     }
 264                 });
 265 
 266         if (flavormapDotProperties != null) {
 267             try {
 268                 parseAndStoreReader(flavormapDotProperties);
 269             } catch (IOException e) {
 270                 System.err.println("IOException:" + e + " while parsing default flavormap.properties file");
 271             }
 272         }
 273 
 274         if (flavormapURL != null) {
 275             try {
 276                 parseAndStoreReader(flavormapURL);
 277             } catch (IOException e) {
 278                 System.err.println("IOException:" + e + " while parsing AWT.DnD.flavorMapFileURL");
 279             }
 280         }
 281     }
 282     /**
 283      * Copied code from java.util.Properties. Parsing the data ourselves is the
 284      * only way to handle duplicate keys and values.
 285      */
 286     private void parseAndStoreReader(BufferedReader in) throws IOException {
 287         while (true) {
 288             // Get next line
 289             String line = in.readLine();
 290             if (line == null) {
 291                 return;
 292             }
 293 
 294             if (line.length() > 0) {
 295                 // Continue lines that end in slashes if they are not comments
 296                 char firstChar = line.charAt(0);
 297                 if (firstChar != '#' && firstChar != '!') {
 298                     while (continueLine(line)) {
 299                         String nextLine = in.readLine();
 300                         if (nextLine == null) {
 301                             nextLine = "";
 302                         }
 303                         String loppedLine =
 304                             line.substring(0, line.length() - 1);
 305                         // Advance beyond whitespace on new line
 306                         int startIndex = 0;
 307                         for(; startIndex < nextLine.length(); startIndex++) {
 308                             if (whiteSpaceChars.
 309                                     indexOf(nextLine.charAt(startIndex)) == -1)
 310                             {
 311                                 break;
 312                             }
 313                         }
 314                         nextLine = nextLine.substring(startIndex,
 315                                                       nextLine.length());
 316                         line = loppedLine+nextLine;
 317                     }
 318 
 319                     // Find start of key
 320                     int len = line.length();
 321                     int keyStart = 0;
 322                     for(; keyStart < len; keyStart++) {
 323                         if(whiteSpaceChars.
 324                                indexOf(line.charAt(keyStart)) == -1) {
 325                             break;
 326                         }
 327                     }
 328 
 329                     // Blank lines are ignored
 330                     if (keyStart == len) {
 331                         continue;
 332                     }
 333 
 334                     // Find separation between key and value
 335                     int separatorIndex = keyStart;
 336                     for(; separatorIndex < len; separatorIndex++) {
 337                         char currentChar = line.charAt(separatorIndex);
 338                         if (currentChar == '\\') {
 339                             separatorIndex++;
 340                         } else if (keyValueSeparators.
 341                                        indexOf(currentChar) != -1) {
 342                             break;
 343                         }
 344                     }
 345 
 346                     // Skip over whitespace after key if any
 347                     int valueIndex = separatorIndex;
 348                     for (; valueIndex < len; valueIndex++) {
 349                         if (whiteSpaceChars.
 350                                 indexOf(line.charAt(valueIndex)) == -1) {
 351                             break;
 352                         }
 353                     }
 354 
 355                     // Skip over one non whitespace key value separators if any
 356                     if (valueIndex < len) {
 357                         if (strictKeyValueSeparators.
 358                                 indexOf(line.charAt(valueIndex)) != -1) {
 359                             valueIndex++;
 360                         }
 361                     }
 362 
 363                     // Skip over white space after other separators if any
 364                     while (valueIndex < len) {
 365                         if (whiteSpaceChars.
 366                                 indexOf(line.charAt(valueIndex)) == -1) {
 367                             break;
 368                         }
 369                         valueIndex++;
 370                     }
 371 
 372                     String key = line.substring(keyStart, separatorIndex);
 373                     String value = (separatorIndex < len)
 374                         ? line.substring(valueIndex, len)
 375                         : "";
 376 
 377                     // Convert then store key and value
 378                     key = loadConvert(key);
 379                     value = loadConvert(value);
 380 
 381                     try {
 382                         MimeType mime = new MimeType(value);
 383                         if ("text".equals(mime.getPrimaryType())) {
 384                             String charset = mime.getParameter("charset");
 385                             if (DataTransferer.doesSubtypeSupportCharset
 386                                     (mime.getSubType(), charset))
 387                             {
 388                                 // We need to store the charset and eoln
 389                                 // parameters, if any, so that the
 390                                 // DataTransferer will have this information
 391                                 // for conversion into the native format.
 392                                 DataTransferer transferer =
 393                                     DataTransferer.getInstance();
 394                                 if (transferer != null) {
 395                                     transferer.registerTextFlavorProperties
 396                                         (key, charset,
 397                                          mime.getParameter("eoln"),
 398                                          mime.getParameter("terminators"));
 399                                 }
 400                             }
 401 
 402                             // But don't store any of these parameters in the
 403                             // DataFlavor itself for any text natives (even
 404                             // non-charset ones). The SystemFlavorMap will
 405                             // synthesize the appropriate mappings later.
 406                             mime.removeParameter("charset");
 407                             mime.removeParameter("class");
 408                             mime.removeParameter("eoln");
 409                             mime.removeParameter("terminators");
 410                             value = mime.toString();
 411                         }
 412                     } catch (MimeTypeParseException e) {
 413                         e.printStackTrace();
 414                         continue;
 415                     }
 416 
 417                     DataFlavor flavor;
 418                     try {
 419                         flavor = new DataFlavor(value);
 420                     } catch (Exception e) {
 421                         try {
 422                             flavor = new DataFlavor(value, (String)null);
 423                         } catch (Exception ee) {
 424                             ee.printStackTrace();
 425                             continue;
 426                         }
 427                     }
 428 
 429                     final LinkedHashSet<DataFlavor> dfs = new LinkedHashSet<>();
 430 
 431                     dfs.add(flavor);
 432 
 433                     if ("text".equals(flavor.getPrimaryType())) {
 434                         dfs.addAll(convertMimeTypeToDataFlavors(value));
 435                     }
 436 
 437                     for (DataFlavor df : dfs) {
 438                         store(df, key, getFlavorToNative());
 439                         store(key, df, getNativeToFlavor());
 440                     }
 441                 }
 442             }
 443         }
 444     }
 445 
 446     /**
 447      * Copied from java.util.Properties.
 448      */
 449     private boolean continueLine (String line) {
 450         int slashCount = 0;
 451         int index = line.length() - 1;
 452         while((index >= 0) && (line.charAt(index--) == '\\')) {
 453             slashCount++;
 454         }
 455         return (slashCount % 2 == 1);
 456     }
 457 
 458     /**
 459      * Copied from java.util.Properties.
 460      */
 461     private String loadConvert(String theString) {
 462         char aChar;
 463         int len = theString.length();
 464         StringBuilder outBuffer = new StringBuilder(len);
 465 
 466         for (int x = 0; x < len; ) {
 467             aChar = theString.charAt(x++);
 468             if (aChar == '\\') {
 469                 aChar = theString.charAt(x++);
 470                 if (aChar == 'u') {
 471                     // Read the xxxx
 472                     int value = 0;
 473                     for (int i = 0; i < 4; i++) {
 474                         aChar = theString.charAt(x++);
 475                         switch (aChar) {
 476                           case '0': case '1': case '2': case '3': case '4':
 477                           case '5': case '6': case '7': case '8': case '9': {
 478                              value = (value << 4) + aChar - '0';
 479                              break;
 480                           }
 481                           case 'a': case 'b': case 'c':
 482                           case 'd': case 'e': case 'f': {
 483                              value = (value << 4) + 10 + aChar - 'a';
 484                              break;
 485                           }
 486                           case 'A': case 'B': case 'C':
 487                           case 'D': case 'E': case 'F': {
 488                              value = (value << 4) + 10 + aChar - 'A';
 489                              break;
 490                           }
 491                           default: {
 492                               throw new IllegalArgumentException(
 493                                            "Malformed \\uxxxx encoding.");
 494                           }
 495                         }
 496                     }
 497                     outBuffer.append((char)value);
 498                 } else {
 499                     if (aChar == 't') {
 500                         aChar = '\t';
 501                     } else if (aChar == 'r') {
 502                         aChar = '\r';
 503                     } else if (aChar == 'n') {
 504                         aChar = '\n';
 505                     } else if (aChar == 'f') {
 506                         aChar = '\f';
 507                     }
 508                     outBuffer.append(aChar);
 509                 }
 510             } else {
 511                 outBuffer.append(aChar);
 512             }
 513         }
 514         return outBuffer.toString();
 515     }
 516 
 517     /**
 518      * Stores the listed object under the specified hash key in map. Unlike a
 519      * standard map, the listed object will not replace any object already at
 520      * the appropriate Map location, but rather will be appended to a List
 521      * stored in that location.
 522      */
 523     private <H, L> void store(H hashed, L listed, Map<H, List<L>> map) {
 524         List<L> list = map.get(hashed);
 525         if (list == null) {
 526             list = new ArrayList<>(1);
 527             map.put(hashed, list);
 528         }
 529         if (!list.contains(listed)) {
 530             list.add(listed);
 531         }
 532     }
 533 
 534     /**
 535      * Semantically equivalent to 'nativeToFlavor.get(nat)'. This method
 536      * handles the case where 'nat' is not found in 'nativeToFlavor'. In that
 537      * case, a new DataFlavor is synthesized, stored, and returned, if and
 538      * only if the specified native is encoded as a Java MIME type.
 539      */
 540     private List<DataFlavor> nativeToFlavorLookup(String nat) {
 541         List<DataFlavor> flavors = getNativeToFlavor().get(nat);
 542 
 543         if (nat != null && !disabledMappingGenerationKeys.contains(nat)) {
 544             DataTransferer transferer = DataTransferer.getInstance();
 545             if (transferer != null) {
 546                 List<DataFlavor> platformFlavors =
 547                     transferer.getPlatformMappingsForNative(nat);
 548                 if (!platformFlavors.isEmpty()) {
 549                     if (flavors != null) {
 550                         platformFlavors.removeAll(new HashSet<>(flavors));
 551                         // Prepending the platform-specific mappings ensures
 552                         // that the flavors added with
 553                         // addFlavorForUnencodedNative() are at the end of
 554                         // list.
 555                         platformFlavors.addAll(flavors);
 556                     }
 557                     flavors = platformFlavors;
 558                 }
 559             }
 560         }
 561 
 562         if (flavors == null && isJavaMIMEType(nat)) {
 563             String decoded = decodeJavaMIMEType(nat);
 564             DataFlavor flavor = null;
 565 
 566             try {
 567                 flavor = new DataFlavor(decoded);
 568             } catch (Exception e) {
 569                 System.err.println("Exception \"" + e.getClass().getName() +
 570                                    ": " + e.getMessage()  +
 571                                    "\"while constructing DataFlavor for: " +
 572                                    decoded);
 573             }
 574 
 575             if (flavor != null) {
 576                 flavors = new ArrayList<>(1);
 577                 getNativeToFlavor().put(nat, flavors);
 578                 flavors.add(flavor);
 579                 getFlavorsForNativeCache.remove(nat);
 580                 getFlavorsForNativeCache.remove(null);
 581 
 582                 List<String> natives = getFlavorToNative().get(flavor);
 583                 if (natives == null) {
 584                     natives = new ArrayList<>(1);
 585                     getFlavorToNative().put(flavor, natives);
 586                 }
 587                 natives.add(nat);
 588                 getNativesForFlavorCache.remove(flavor);
 589                 getNativesForFlavorCache.remove(null);
 590             }
 591         }
 592 
 593         return (flavors != null) ? flavors : new ArrayList<>(0);
 594     }
 595 
 596     /**
 597      * Semantically equivalent to 'flavorToNative.get(flav)'. This method
 598      * handles the case where 'flav' is not found in 'flavorToNative' depending
 599      * on the value of passes 'synthesize' parameter. If 'synthesize' is
 600      * SYNTHESIZE_IF_NOT_FOUND a native is synthesized, stored, and returned by
 601      * encoding the DataFlavor's MIME type. Otherwise an empty List is returned
 602      * and 'flavorToNative' remains unaffected.
 603      */
 604     private List<String> flavorToNativeLookup(final DataFlavor flav,
 605                                               final boolean synthesize) {
 606         List<String> natives = getFlavorToNative().get(flav);
 607 
 608         if (flav != null && !disabledMappingGenerationKeys.contains(flav)) {
 609             DataTransferer transferer = DataTransferer.getInstance();
 610             if (transferer != null) {
 611                 List<String> platformNatives =
 612                     transferer.getPlatformMappingsForFlavor(flav);
 613                 if (!platformNatives.isEmpty()) {
 614                     if (natives != null) {
 615                         platformNatives.removeAll(new HashSet<>(natives));
 616                         // Prepend the platform-specific mappings to ensure
 617                         // that the natives added with
 618                         // addUnencodedNativeForFlavor() are at the end of
 619                         // list.
 620                         platformNatives.addAll(natives);
 621                     }
 622                     natives = platformNatives;
 623                 }
 624             }
 625         }
 626 
 627         if (natives == null) {
 628             if (synthesize) {
 629                 String encoded = encodeDataFlavor(flav);
 630                 natives = new ArrayList<>(1);
 631                 getFlavorToNative().put(flav, natives);
 632                 natives.add(encoded);
 633                 getNativesForFlavorCache.remove(flav);
 634                 getNativesForFlavorCache.remove(null);
 635 
 636                 List<DataFlavor> flavors = getNativeToFlavor().get(encoded);
 637                 if (flavors == null) {
 638                     flavors = new ArrayList<>(1);
 639                     getNativeToFlavor().put(encoded, flavors);
 640                 }
 641                 flavors.add(flav);
 642                 getFlavorsForNativeCache.remove(encoded);
 643                 getFlavorsForNativeCache.remove(null);
 644             } else {
 645                 natives = new ArrayList<>(0);
 646             }
 647         }
 648 
 649         return natives;
 650     }
 651 
 652     /**
 653      * Returns a <code>List</code> of <code>String</code> natives to which the
 654      * specified <code>DataFlavor</code> can be translated by the data transfer
 655      * subsystem. The <code>List</code> will be sorted from best native to
 656      * worst. That is, the first native will best reflect data in the specified
 657      * flavor to the underlying native platform.
 658      * <p>
 659      * If the specified <code>DataFlavor</code> is previously unknown to the
 660      * data transfer subsystem and the data transfer subsystem is unable to
 661      * translate this <code>DataFlavor</code> to any existing native, then
 662      * invoking this method will establish a
 663      * mapping in both directions between the specified <code>DataFlavor</code>
 664      * and an encoded version of its MIME type as its native.
 665      *
 666      * @param flav the <code>DataFlavor</code> whose corresponding natives
 667      *        should be returned. If <code>null</code> is specified, all
 668      *        natives currently known to the data transfer subsystem are
 669      *        returned in a non-deterministic order.
 670      * @return a <code>java.util.List</code> of <code>java.lang.String</code>
 671      *         objects which are platform-specific representations of platform-
 672      *         specific data formats
 673      *
 674      * @see #encodeDataFlavor
 675      * @since 1.4
 676      */
 677     public synchronized List<String> getNativesForFlavor(DataFlavor flav) {
 678         List<String> retval = null;
 679 
 680         // Check cache, even for null flav
 681         SoftReference<List<String>> ref = getNativesForFlavorCache.get(flav);
 682         if (ref != null) {
 683             retval = ref.get();
 684             if (retval != null) {
 685                 // Create a copy, because client code can modify the returned
 686                 // list.
 687                 return new ArrayList<>(retval);
 688             }
 689         }
 690 
 691         if (flav == null) {
 692             retval = new ArrayList<>(getNativeToFlavor().keySet());
 693         } else if (disabledMappingGenerationKeys.contains(flav)) {
 694             // In this case we shouldn't synthesize a native for this flavor,
 695             // since its mappings were explicitly specified.
 696             retval = flavorToNativeLookup(flav, !SYNTHESIZE_IF_NOT_FOUND);
 697         } else if (DataTransferer.isFlavorCharsetTextType(flav)) {
 698 
 699             // For text/* flavors, flavor-to-native mappings specified in
 700             // flavormap.properties are stored per flavor's base type.
 701             if ("text".equals(flav.getPrimaryType())) {
 702                 retval = getAllNativesForType(flav.mimeType.getBaseType());
 703                 if (retval != null) {
 704                     // To prevent the List stored in the map from modification.
 705                     retval = new ArrayList(retval);
 706                 }
 707             }
 708 
 709             // Also include text/plain natives, but don't duplicate Strings
 710             List<String> textPlainList = getAllNativesForType(TEXT_PLAIN_BASE_TYPE);
 711 
 712             if (textPlainList != null && !textPlainList.isEmpty()) {
 713                 // To prevent the List stored in the map from modification.
 714                 // This also guarantees that removeAll() is supported.
 715                 textPlainList = new ArrayList<>(textPlainList);
 716                 if (retval != null && !retval.isEmpty()) {
 717                     // Use HashSet to get constant-time performance for search.
 718                     textPlainList.removeAll(new HashSet<>(retval));
 719                     retval.addAll(textPlainList);
 720                 } else {
 721                     retval = textPlainList;
 722                 }
 723             }
 724 
 725             if (retval == null || retval.isEmpty()) {
 726                 retval = flavorToNativeLookup(flav, SYNTHESIZE_IF_NOT_FOUND);
 727             } else {
 728                 // In this branch it is guaranteed that natives explicitly
 729                 // listed for flav's MIME type were added with
 730                 // addUnencodedNativeForFlavor(), so they have lower priority.
 731                 List<String> explicitList =
 732                     flavorToNativeLookup(flav, !SYNTHESIZE_IF_NOT_FOUND);
 733 
 734                 // flavorToNativeLookup() never returns null.
 735                 // It can return an empty List, however.
 736                 if (!explicitList.isEmpty()) {
 737                     // To prevent the List stored in the map from modification.
 738                     // This also guarantees that removeAll() is supported.
 739                     explicitList = new ArrayList<>(explicitList);
 740                     // Use HashSet to get constant-time performance for search.
 741                     explicitList.removeAll(new HashSet<>(retval));
 742                     retval.addAll(explicitList);
 743                 }
 744             }
 745         } else if (DataTransferer.isFlavorNoncharsetTextType(flav)) {
 746             retval = getAllNativesForType(flav.mimeType.getBaseType());
 747 
 748             if (retval == null || retval.isEmpty()) {
 749                 retval = flavorToNativeLookup(flav, SYNTHESIZE_IF_NOT_FOUND);
 750             } else {
 751                 // In this branch it is guaranteed that natives explicitly
 752                 // listed for flav's MIME type were added with
 753                 // addUnencodedNativeForFlavor(), so they have lower priority.
 754                 List<String> explicitList =
 755                     flavorToNativeLookup(flav, !SYNTHESIZE_IF_NOT_FOUND);
 756 
 757                 // flavorToNativeLookup() never returns null.
 758                 // It can return an empty List, however.
 759                 if (!explicitList.isEmpty()) {
 760                     // To prevent the List stored in the map from modification.
 761                     // This also guarantees that add/removeAll() are supported.
 762                     retval = new ArrayList<>(retval);
 763                     explicitList = new ArrayList<>(explicitList);
 764                     // Use HashSet to get constant-time performance for search.
 765                     explicitList.removeAll(new HashSet<>(retval));
 766                     retval.addAll(explicitList);
 767                 }
 768             }
 769         } else {
 770             retval = flavorToNativeLookup(flav, SYNTHESIZE_IF_NOT_FOUND);
 771         }
 772 
 773         getNativesForFlavorCache.put(flav, new SoftReference<>(retval));
 774         // Create a copy, because client code can modify the returned list.
 775         return new ArrayList<>(retval);
 776     }
 777 
 778     /**
 779      * Returns a <code>List</code> of <code>DataFlavor</code>s to which the
 780      * specified <code>String</code> native can be translated by the data
 781      * transfer subsystem. The <code>List</code> will be sorted from best
 782      * <code>DataFlavor</code> to worst. That is, the first
 783      * <code>DataFlavor</code> will best reflect data in the specified
 784      * native to a Java application.
 785      * <p>
 786      * If the specified native is previously unknown to the data transfer
 787      * subsystem, and that native has been properly encoded, then invoking this
 788      * method will establish a mapping in both directions between the specified
 789      * native and a <code>DataFlavor</code> whose MIME type is a decoded
 790      * version of the native.
 791      * <p>
 792      * If the specified native is not a properly encoded native and the
 793      * mappings for this native have not been altered with
 794      * <code>setFlavorsForNative</code>, then the contents of the
 795      * <code>List</code> is platform dependent, but <code>null</code>
 796      * cannot be returned.
 797      *
 798      * @param nat the native whose corresponding <code>DataFlavor</code>s
 799      *        should be returned. If <code>null</code> is specified, all
 800      *        <code>DataFlavor</code>s currently known to the data transfer
 801      *        subsystem are returned in a non-deterministic order.
 802      * @return a <code>java.util.List</code> of <code>DataFlavor</code>
 803      *         objects into which platform-specific data in the specified,
 804      *         platform-specific native can be translated
 805      *
 806      * @see #encodeJavaMIMEType
 807      * @since 1.4
 808      */
 809     public synchronized List<DataFlavor> getFlavorsForNative(String nat) {
 810 
 811         // Check cache, even for null nat
 812         SoftReference<List<DataFlavor>> ref = getFlavorsForNativeCache.get(nat);
 813         if (ref != null) {
 814             List<DataFlavor> retval = ref.get();
 815             if (retval != null) {
 816                 return new ArrayList<>(retval);
 817             }
 818         }
 819 
 820         final LinkedHashSet <DataFlavor> returnValue =
 821             new LinkedHashSet<>();
 822 
 823         if (nat == null) {
 824             final List<String> natives = getNativesForFlavor(null);
 825 
 826             for (String n : natives)
 827             {
 828                 final List<DataFlavor> flavors = getFlavorsForNative(n);
 829 
 830                 for (DataFlavor df : flavors)
 831                 {
 832                     returnValue.add(df);
 833                 }
 834             }
 835         } else {
 836 
 837             final List<DataFlavor> flavors = nativeToFlavorLookup(nat);
 838 
 839             if (disabledMappingGenerationKeys.contains(nat)) {
 840                 return flavors;
 841             }
 842 
 843             final List<DataFlavor> flavorsAndBaseTypes =
 844                 nativeToFlavorLookup(nat);
 845 
 846             for (DataFlavor df : flavorsAndBaseTypes) {
 847                 returnValue.add(df);
 848                 if ("text".equals(df.getPrimaryType())) {
 849                     try {
 850                         returnValue.addAll(
 851                                 convertMimeTypeToDataFlavors(
 852                                         new MimeType(df.getMimeType()
 853                                         ).getBaseType()));
 854                     } catch (MimeTypeParseException e) {
 855                         e.printStackTrace();
 856                     }
 857                 }
 858             }
 859 
 860         }
 861 
 862         final List<DataFlavor> arrayList = new ArrayList<>(returnValue);
 863         getFlavorsForNativeCache.put(nat, new SoftReference<>(arrayList));
 864         return new ArrayList<>(arrayList);
 865     }
 866 
 867     private static Set<DataFlavor> convertMimeTypeToDataFlavors(
 868         final String baseType) {
 869 
 870         final Set<DataFlavor> returnValue = new LinkedHashSet<>();
 871 
 872         String subType = null;
 873 
 874         try {
 875             final MimeType mimeType = new MimeType(baseType);
 876             subType = mimeType.getSubType();
 877         } catch (MimeTypeParseException mtpe) {
 878             // Cannot happen, since we checked all mappings
 879             // on load from flavormap.properties.
 880             assert(false);
 881         }
 882 
 883         if (DataTransferer.doesSubtypeSupportCharset(subType, null)) {
 884             if (TEXT_PLAIN_BASE_TYPE.equals(baseType))
 885             {
 886                 returnValue.add(DataFlavor.stringFlavor);
 887             }
 888 
 889             for (String unicodeClassName : UNICODE_TEXT_CLASSES) {
 890                 final String mimeType = baseType + ";charset=Unicode;class=" +
 891                                             unicodeClassName;
 892 
 893                 final LinkedHashSet<String> mimeTypes =
 894                     handleHtmlMimeTypes(baseType, mimeType);
 895                 for (String mt : mimeTypes) {
 896                     DataFlavor toAdd = null;
 897                     try {
 898                         toAdd = new DataFlavor(mt);
 899                     } catch (ClassNotFoundException cannotHappen) {
 900                     }
 901                     returnValue.add(toAdd);
 902                 }
 903             }
 904 
 905             for (String charset : DataTransferer.standardEncodings()) {
 906 
 907                 for (String encodedTextClass : ENCODED_TEXT_CLASSES) {
 908                     final String mimeType =
 909                             baseType + ";charset=" + charset +
 910                             ";class=" + encodedTextClass;
 911 
 912                     final LinkedHashSet<String> mimeTypes =
 913                         handleHtmlMimeTypes(baseType, mimeType);
 914 
 915                     for (String mt : mimeTypes) {
 916 
 917                         DataFlavor df = null;
 918 
 919                         try {
 920                             df = new DataFlavor(mt);
 921                             // Check for equality to plainTextFlavor so
 922                             // that we can ensure that the exact charset of
 923                             // plainTextFlavor, not the canonical charset
 924                             // or another equivalent charset with a
 925                             // different name, is used.
 926                             if (df.equals(DataFlavor.plainTextFlavor)) {
 927                                 df = DataFlavor.plainTextFlavor;
 928                             }
 929                         } catch (ClassNotFoundException cannotHappen) {
 930                         }
 931 
 932                         returnValue.add(df);
 933                     }
 934                 }
 935             }
 936 
 937             if (TEXT_PLAIN_BASE_TYPE.equals(baseType))
 938             {
 939                 returnValue.add(DataFlavor.plainTextFlavor);
 940             }
 941         } else {
 942             // Non-charset text natives should be treated as
 943             // opaque, 8-bit data in any of its various
 944             // representations.
 945             for (String encodedTextClassName : ENCODED_TEXT_CLASSES) {
 946                 DataFlavor toAdd = null;
 947                 try {
 948                     toAdd = new DataFlavor(baseType +
 949                          ";class=" + encodedTextClassName);
 950                 } catch (ClassNotFoundException cannotHappen) {
 951                 }
 952                 returnValue.add(toAdd);
 953             }
 954         }
 955         return returnValue;
 956     }
 957 
 958     private static final String [] htmlDocumntTypes =
 959         new String [] {"all", "selection", "fragment"};
 960 
 961     private static LinkedHashSet<String> handleHtmlMimeTypes(
 962         String baseType, String mimeType) {
 963 
 964         LinkedHashSet<String> returnValues = new LinkedHashSet<>();
 965 
 966         if (HTML_TEXT_BASE_TYPE.equals(baseType)) {
 967             for (String documentType : htmlDocumntTypes) {
 968                 returnValues.add(mimeType + ";document=" + documentType);
 969             }
 970         } else {
 971             returnValues.add(mimeType);
 972         }
 973 
 974         return returnValues;
 975     }
 976 
 977     /**
 978      * Returns a <code>Map</code> of the specified <code>DataFlavor</code>s to
 979      * their most preferred <code>String</code> native. Each native value will
 980      * be the same as the first native in the List returned by
 981      * <code>getNativesForFlavor</code> for the specified flavor.
 982      * <p>
 983      * If a specified <code>DataFlavor</code> is previously unknown to the
 984      * data transfer subsystem, then invoking this method will establish a
 985      * mapping in both directions between the specified <code>DataFlavor</code>
 986      * and an encoded version of its MIME type as its native.
 987      *
 988      * @param flavors an array of <code>DataFlavor</code>s which will be the
 989      *        key set of the returned <code>Map</code>. If <code>null</code> is
 990      *        specified, a mapping of all <code>DataFlavor</code>s known to the
 991      *        data transfer subsystem to their most preferred
 992      *        <code>String</code> natives will be returned.
 993      * @return a <code>java.util.Map</code> of <code>DataFlavor</code>s to
 994      *         <code>String</code> natives
 995      *
 996      * @see #getNativesForFlavor
 997      * @see #encodeDataFlavor
 998      */
 999     public synchronized Map<DataFlavor,String>
1000         getNativesForFlavors(DataFlavor[] flavors)
1001     {
1002         // Use getNativesForFlavor to generate extra natives for text flavors
1003         // and stringFlavor
1004 
1005         if (flavors == null) {
1006             List flavor_list = getFlavorsForNative(null);
1007             flavors = new DataFlavor[flavor_list.size()];
1008             flavor_list.toArray(flavors);
1009         }
1010 
1011         Map<DataFlavor, String> retval = new HashMap<>(flavors.length, 1.0f);
1012         for (DataFlavor flavor : flavors) {
1013             List<String> natives = getNativesForFlavor(flavor);
1014             String nat = (natives.isEmpty()) ? null : natives.get(0);
1015             retval.put(flavor, nat);
1016         }
1017 
1018         return retval;
1019     }
1020 
1021     /**
1022      * Returns a <code>Map</code> of the specified <code>String</code> natives
1023      * to their most preferred <code>DataFlavor</code>. Each
1024      * <code>DataFlavor</code> value will be the same as the first
1025      * <code>DataFlavor</code> in the List returned by
1026      * <code>getFlavorsForNative</code> for the specified native.
1027      * <p>
1028      * If a specified native is previously unknown to the data transfer
1029      * subsystem, and that native has been properly encoded, then invoking this
1030      * method will establish a mapping in both directions between the specified
1031      * native and a <code>DataFlavor</code> whose MIME type is a decoded
1032      * version of the native.
1033      *
1034      * @param natives an array of <code>String</code>s which will be the
1035      *        key set of the returned <code>Map</code>. If <code>null</code> is
1036      *        specified, a mapping of all supported <code>String</code> natives
1037      *        to their most preferred <code>DataFlavor</code>s will be
1038      *        returned.
1039      * @return a <code>java.util.Map</code> of <code>String</code> natives to
1040      *         <code>DataFlavor</code>s
1041      *
1042      * @see #getFlavorsForNative
1043      * @see #encodeJavaMIMEType
1044      */
1045     public synchronized Map<String,DataFlavor>
1046         getFlavorsForNatives(String[] natives)
1047     {
1048         // Use getFlavorsForNative to generate extra flavors for text natives
1049 
1050         if (natives == null) {
1051             List native_list = getNativesForFlavor(null);
1052             natives = new String[native_list.size()];
1053             native_list.toArray(natives);
1054         }
1055 
1056         Map<String, DataFlavor> retval = new HashMap<>(natives.length, 1.0f);
1057         for (String aNative : natives) {
1058             List<DataFlavor> flavors = getFlavorsForNative(aNative);
1059             DataFlavor flav = (flavors.isEmpty())? null : flavors.get(0);
1060             retval.put(aNative, flav);
1061         }
1062 
1063         return retval;
1064     }
1065 
1066     /**
1067      * Adds a mapping from the specified <code>DataFlavor</code> (and all
1068      * <code>DataFlavor</code>s equal to the specified <code>DataFlavor</code>)
1069      * to the specified <code>String</code> native.
1070      * Unlike <code>getNativesForFlavor</code>, the mapping will only be
1071      * established in one direction, and the native will not be encoded. To
1072      * establish a two-way mapping, call
1073      * <code>addFlavorForUnencodedNative</code> as well. The new mapping will
1074      * be of lower priority than any existing mapping.
1075      * This method has no effect if a mapping from the specified or equal
1076      * <code>DataFlavor</code> to the specified <code>String</code> native
1077      * already exists.
1078      *
1079      * @param flav the <code>DataFlavor</code> key for the mapping
1080      * @param nat the <code>String</code> native value for the mapping
1081      * @throws NullPointerException if flav or nat is <code>null</code>
1082      *
1083      * @see #addFlavorForUnencodedNative
1084      * @since 1.4
1085      */
1086     public synchronized void addUnencodedNativeForFlavor(DataFlavor flav,
1087                                                          String nat) {
1088         if (flav == null || nat == null) {
1089             throw new NullPointerException("null arguments not permitted");
1090         }
1091 
1092         List<String> natives = getFlavorToNative().get(flav);
1093         if (natives == null) {
1094             natives = new ArrayList<>(1);
1095             getFlavorToNative().put(flav, natives);
1096         } else if (natives.contains(nat)) {
1097             return;
1098         }
1099         natives.add(nat);
1100         getNativesForFlavorCache.remove(flav);
1101         getNativesForFlavorCache.remove(null);
1102     }
1103 
1104     /**
1105      * Discards the current mappings for the specified <code>DataFlavor</code>
1106      * and all <code>DataFlavor</code>s equal to the specified
1107      * <code>DataFlavor</code>, and creates new mappings to the
1108      * specified <code>String</code> natives.
1109      * Unlike <code>getNativesForFlavor</code>, the mappings will only be
1110      * established in one direction, and the natives will not be encoded. To
1111      * establish two-way mappings, call <code>setFlavorsForNative</code>
1112      * as well. The first native in the array will represent the highest
1113      * priority mapping. Subsequent natives will represent mappings of
1114      * decreasing priority.
1115      * <p>
1116      * If the array contains several elements that reference equal
1117      * <code>String</code> natives, this method will establish new mappings
1118      * for the first of those elements and ignore the rest of them.
1119      * <p>
1120      * It is recommended that client code not reset mappings established by the
1121      * data transfer subsystem. This method should only be used for
1122      * application-level mappings.
1123      *
1124      * @param flav the <code>DataFlavor</code> key for the mappings
1125      * @param natives the <code>String</code> native values for the mappings
1126      * @throws NullPointerException if flav or natives is <code>null</code>
1127      *         or if natives contains <code>null</code> elements
1128      *
1129      * @see #setFlavorsForNative
1130      * @since 1.4
1131      */
1132     public synchronized void setNativesForFlavor(DataFlavor flav,
1133                                                  String[] natives) {
1134         if (flav == null || natives == null) {
1135             throw new NullPointerException("null arguments not permitted");
1136         }
1137 
1138         getFlavorToNative().remove(flav);
1139         for (String aNative : natives) {
1140             addUnencodedNativeForFlavor(flav, aNative);
1141         }
1142         disabledMappingGenerationKeys.add(flav);
1143         // Clear the cache to handle the case of empty natives.
1144         getNativesForFlavorCache.remove(flav);
1145         getNativesForFlavorCache.remove(null);
1146     }
1147 
1148     /**
1149      * Adds a mapping from a single <code>String</code> native to a single
1150      * <code>DataFlavor</code>. Unlike <code>getFlavorsForNative</code>, the
1151      * mapping will only be established in one direction, and the native will
1152      * not be encoded. To establish a two-way mapping, call
1153      * <code>addUnencodedNativeForFlavor</code> as well. The new mapping will
1154      * be of lower priority than any existing mapping.
1155      * This method has no effect if a mapping from the specified
1156      * <code>String</code> native to the specified or equal
1157      * <code>DataFlavor</code> already exists.
1158      *
1159      * @param nat the <code>String</code> native key for the mapping
1160      * @param flav the <code>DataFlavor</code> value for the mapping
1161      * @throws NullPointerException if nat or flav is <code>null</code>
1162      *
1163      * @see #addUnencodedNativeForFlavor
1164      * @since 1.4
1165      */
1166     public synchronized void addFlavorForUnencodedNative(String nat,
1167                                                          DataFlavor flav) {
1168         if (nat == null || flav == null) {
1169             throw new NullPointerException("null arguments not permitted");
1170         }
1171 
1172         List<DataFlavor> flavors = getNativeToFlavor().get(nat);
1173         if (flavors == null) {
1174             flavors = new ArrayList<>(1);
1175             getNativeToFlavor().put(nat, flavors);
1176         } else if (flavors.contains(flav)) {
1177             return;
1178         }
1179         flavors.add(flav);
1180         getFlavorsForNativeCache.remove(nat);
1181         getFlavorsForNativeCache.remove(null);
1182     }
1183 
1184     /**
1185      * Discards the current mappings for the specified <code>String</code>
1186      * native, and creates new mappings to the specified
1187      * <code>DataFlavor</code>s. Unlike <code>getFlavorsForNative</code>, the
1188      * mappings will only be established in one direction, and the natives need
1189      * not be encoded. To establish two-way mappings, call
1190      * <code>setNativesForFlavor</code> as well. The first
1191      * <code>DataFlavor</code> in the array will represent the highest priority
1192      * mapping. Subsequent <code>DataFlavor</code>s will represent mappings of
1193      * decreasing priority.
1194      * <p>
1195      * If the array contains several elements that reference equal
1196      * <code>DataFlavor</code>s, this method will establish new mappings
1197      * for the first of those elements and ignore the rest of them.
1198      * <p>
1199      * It is recommended that client code not reset mappings established by the
1200      * data transfer subsystem. This method should only be used for
1201      * application-level mappings.
1202      *
1203      * @param nat the <code>String</code> native key for the mappings
1204      * @param flavors the <code>DataFlavor</code> values for the mappings
1205      * @throws NullPointerException if nat or flavors is <code>null</code>
1206      *         or if flavors contains <code>null</code> elements
1207      *
1208      * @see #setNativesForFlavor
1209      * @since 1.4
1210      */
1211     public synchronized void setFlavorsForNative(String nat,
1212                                                  DataFlavor[] flavors) {
1213         if (nat == null || flavors == null) {
1214             throw new NullPointerException("null arguments not permitted");
1215         }
1216 
1217         getNativeToFlavor().remove(nat);
1218         for (DataFlavor flavor : flavors) {
1219             addFlavorForUnencodedNative(nat, flavor);
1220         }
1221         disabledMappingGenerationKeys.add(nat);
1222         // Clear the cache to handle the case of empty flavors.
1223         getFlavorsForNativeCache.remove(nat);
1224         getFlavorsForNativeCache.remove(null);
1225     }
1226 
1227     /**
1228      * Encodes a MIME type for use as a <code>String</code> native. The format
1229      * of an encoded representation of a MIME type is implementation-dependent.
1230      * The only restrictions are:
1231      * <ul>
1232      * <li>The encoded representation is <code>null</code> if and only if the
1233      * MIME type <code>String</code> is <code>null</code>.</li>
1234      * <li>The encoded representations for two non-<code>null</code> MIME type
1235      * <code>String</code>s are equal if and only if these <code>String</code>s
1236      * are equal according to <code>String.equals(Object)</code>.</li>
1237      * </ul>
1238      * <p>
1239      * The reference implementation of this method returns the specified MIME
1240      * type <code>String</code> prefixed with <code>JAVA_DATAFLAVOR:</code>.
1241      *
1242      * @param mimeType the MIME type to encode
1243      * @return the encoded <code>String</code>, or <code>null</code> if
1244      *         mimeType is <code>null</code>
1245      */
1246     public static String encodeJavaMIMEType(String mimeType) {
1247         return (mimeType != null)
1248             ? JavaMIME + mimeType
1249             : null;
1250     }
1251 
1252     /**
1253      * Encodes a <code>DataFlavor</code> for use as a <code>String</code>
1254      * native. The format of an encoded <code>DataFlavor</code> is
1255      * implementation-dependent. The only restrictions are:
1256      * <ul>
1257      * <li>The encoded representation is <code>null</code> if and only if the
1258      * specified <code>DataFlavor</code> is <code>null</code> or its MIME type
1259      * <code>String</code> is <code>null</code>.</li>
1260      * <li>The encoded representations for two non-<code>null</code>
1261      * <code>DataFlavor</code>s with non-<code>null</code> MIME type
1262      * <code>String</code>s are equal if and only if the MIME type
1263      * <code>String</code>s of these <code>DataFlavor</code>s are equal
1264      * according to <code>String.equals(Object)</code>.</li>
1265      * </ul>
1266      * <p>
1267      * The reference implementation of this method returns the MIME type
1268      * <code>String</code> of the specified <code>DataFlavor</code> prefixed
1269      * with <code>JAVA_DATAFLAVOR:</code>.
1270      *
1271      * @param flav the <code>DataFlavor</code> to encode
1272      * @return the encoded <code>String</code>, or <code>null</code> if
1273      *         flav is <code>null</code> or has a <code>null</code> MIME type
1274      */
1275     public static String encodeDataFlavor(DataFlavor flav) {
1276         return (flav != null)
1277             ? SystemFlavorMap.encodeJavaMIMEType(flav.getMimeType())
1278             : null;
1279     }
1280 
1281     /**
1282      * Returns whether the specified <code>String</code> is an encoded Java
1283      * MIME type.
1284      *
1285      * @param str the <code>String</code> to test
1286      * @return <code>true</code> if the <code>String</code> is encoded;
1287      *         <code>false</code> otherwise
1288      */
1289     public static boolean isJavaMIMEType(String str) {
1290         return (str != null && str.startsWith(JavaMIME, 0));
1291     }
1292 
1293     /**
1294      * Decodes a <code>String</code> native for use as a Java MIME type.
1295      *
1296      * @param nat the <code>String</code> to decode
1297      * @return the decoded Java MIME type, or <code>null</code> if nat is not
1298      *         an encoded <code>String</code> native
1299      */
1300     public static String decodeJavaMIMEType(String nat) {
1301         return (isJavaMIMEType(nat))
1302             ? nat.substring(JavaMIME.length(), nat.length()).trim()
1303             : null;
1304     }
1305 
1306     /**
1307      * Decodes a <code>String</code> native for use as a
1308      * <code>DataFlavor</code>.
1309      *
1310      * @param nat the <code>String</code> to decode
1311      * @return the decoded <code>DataFlavor</code>, or <code>null</code> if
1312      *         nat is not an encoded <code>String</code> native
1313      */
1314     public static DataFlavor decodeDataFlavor(String nat)
1315         throws ClassNotFoundException
1316     {
1317         String retval_str = SystemFlavorMap.decodeJavaMIMEType(nat);
1318         return (retval_str != null)
1319             ? new DataFlavor(retval_str)
1320             : null;
1321     }
1322 
1323     private List<String> getAllNativesForType(String type) {
1324         List<String> retval = null;
1325         for (DataFlavor dataFlavor : convertMimeTypeToDataFlavors(type)) {
1326             List<String> natives = getFlavorToNative().get(dataFlavor);
1327             if (!natives.isEmpty()) {
1328                 if (retval == null) {
1329                     retval = new ArrayList<>();
1330                 }
1331                 retval.addAll(natives);
1332             }
1333         }
1334         return retval;
1335     }
1336 }