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 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 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 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 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 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 = (FlavorMap)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 void store(Object hashed, Object listed, Map map) {
 524         List list = (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 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 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 natives = (List)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 flavorToNativeLookup(final DataFlavor flav,
 605                                       final boolean synthesize) {
 606         List natives = (List)getFlavorToNative().get(flav);
 607 
 608         if (flav != null && !disabledMappingGenerationKeys.contains(flav)) {
 609             DataTransferer transferer = DataTransferer.getInstance();
 610             if (transferer != null) {
 611                 List 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 retval = null;
 679 
 680         // Check cache, even for null flav
 681         SoftReference ref = (SoftReference)getNativesForFlavorCache.get(flav);
 682         if (ref != null) {
 683             retval = (List)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<String>(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 = (List)getFlavorToNative().get(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 textPlainList = (List)getFlavorToNative().get(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 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 = (List)getFlavorToNative().get(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 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 ref = (SoftReference)getFlavorsForNativeCache.get(nat);
 813         if (ref != null) {
 814             ArrayList retval = (ArrayList)ref.get();
 815             if (retval != null) {
 816                 return (List)retval.clone();
 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 ArrayList arrayList = new ArrayList(returnValue);
 863         getFlavorsForNativeCache.put(nat, new SoftReference(arrayList));
 864         return (List)arrayList.clone();
 865     }
 866 
 867     private static LinkedHashSet<DataFlavor> convertMimeTypeToDataFlavors(
 868         final String baseType) {
 869 
 870         final LinkedHashSet<DataFlavor> returnValue =
 871             new LinkedHashSet<DataFlavor>();
 872 
 873         String subType = null;
 874 
 875         try {
 876             final MimeType mimeType = new MimeType(baseType);
 877             subType = mimeType.getSubType();
 878         } catch (MimeTypeParseException mtpe) {
 879             // Cannot happen, since we checked all mappings
 880             // on load from flavormap.properties.
 881             assert(false);
 882         }
 883 
 884         if (DataTransferer.doesSubtypeSupportCharset(subType, null)) {
 885             if (TEXT_PLAIN_BASE_TYPE.equals(baseType))
 886             {
 887                 returnValue.add(DataFlavor.stringFlavor);
 888             }
 889 
 890             for (String unicodeClassName : UNICODE_TEXT_CLASSES) {
 891                 final String mimeType = baseType + ";charset=Unicode;class=" +
 892                                             unicodeClassName;
 893 
 894                 final LinkedHashSet<String> mimeTypes =
 895                     handleHtmlMimeTypes(baseType, mimeType);
 896                 for (String mt : mimeTypes) {
 897                     DataFlavor toAdd = null;
 898                     try {
 899                         toAdd = new DataFlavor(mt);
 900                     } catch (ClassNotFoundException cannotHappen) {
 901                     }
 902                     returnValue.add(toAdd);
 903                 }
 904             }
 905 
 906             for (String charset : DataTransferer.standardEncodings()) {
 907 
 908                 for (String encodedTextClass : ENCODED_TEXT_CLASSES) {
 909                     final String mimeType =
 910                             baseType + ";charset=" + charset +
 911                             ";class=" + encodedTextClass;
 912 
 913                     final LinkedHashSet<String> mimeTypes =
 914                         handleHtmlMimeTypes(baseType, mimeType);
 915 
 916                     for (String mt : mimeTypes) {
 917 
 918                         DataFlavor df = null;
 919 
 920                         try {
 921                             df = new DataFlavor(mt);
 922                             // Check for equality to plainTextFlavor so
 923                             // that we can ensure that the exact charset of
 924                             // plainTextFlavor, not the canonical charset
 925                             // or another equivalent charset with a
 926                             // different name, is used.
 927                             if (df.equals(DataFlavor.plainTextFlavor)) {
 928                                 df = DataFlavor.plainTextFlavor;
 929                             }
 930                         } catch (ClassNotFoundException cannotHappen) {
 931                         }
 932 
 933                         returnValue.add(df);
 934                     }
 935                 }
 936             }
 937 
 938             if (TEXT_PLAIN_BASE_TYPE.equals(baseType))
 939             {
 940                 returnValue.add(DataFlavor.plainTextFlavor);
 941             }
 942         } else {
 943             // Non-charset text natives should be treated as
 944             // opaque, 8-bit data in any of its various
 945             // representations.
 946             for (String encodedTextClassName : ENCODED_TEXT_CLASSES) {
 947                 DataFlavor toAdd = null;
 948                 try {
 949                     toAdd = new DataFlavor(baseType +
 950                          ";class=" + encodedTextClassName);
 951                 } catch (ClassNotFoundException cannotHappen) {
 952                 }
 953                 returnValue.add(toAdd);
 954             }
 955         }
 956         return returnValue;
 957     }
 958 
 959     private static final String [] htmlDocumntTypes =
 960         new String [] {"all", "selection", "fragment"};
 961 
 962     private static LinkedHashSet<String> handleHtmlMimeTypes(
 963         String baseType, String mimeType) {
 964 
 965         LinkedHashSet<String> returnValues = new LinkedHashSet<>();
 966 
 967         if (HTML_TEXT_BASE_TYPE.equals(baseType)) {
 968             for (String documentType : htmlDocumntTypes) {
 969                 returnValues.add(mimeType + ";document=" + documentType);
 970             }
 971         } else {
 972             returnValues.add(mimeType);
 973         }
 974 
 975         return returnValues;
 976     }
 977 
 978     /**
 979      * Returns a <code>Map</code> of the specified <code>DataFlavor</code>s to
 980      * their most preferred <code>String</code> native. Each native value will
 981      * be the same as the first native in the List returned by
 982      * <code>getNativesForFlavor</code> for the specified flavor.
 983      * <p>
 984      * If a specified <code>DataFlavor</code> is previously unknown to the
 985      * data transfer subsystem, then invoking this method will establish a
 986      * mapping in both directions between the specified <code>DataFlavor</code>
 987      * and an encoded version of its MIME type as its native.
 988      *
 989      * @param flavors an array of <code>DataFlavor</code>s which will be the
 990      *        key set of the returned <code>Map</code>. If <code>null</code> is
 991      *        specified, a mapping of all <code>DataFlavor</code>s known to the
 992      *        data transfer subsystem to their most preferred
 993      *        <code>String</code> natives will be returned.
 994      * @return a <code>java.util.Map</code> of <code>DataFlavor</code>s to
 995      *         <code>String</code> natives
 996      *
 997      * @see #getNativesForFlavor
 998      * @see #encodeDataFlavor
 999      */
1000     public synchronized Map<DataFlavor,String>
1001         getNativesForFlavors(DataFlavor[] flavors)
1002     {
1003         // Use getNativesForFlavor to generate extra natives for text flavors
1004         // and stringFlavor
1005 
1006         if (flavors == null) {
1007             List flavor_list = getFlavorsForNative(null);
1008             flavors = new DataFlavor[flavor_list.size()];
1009             flavor_list.toArray(flavors);
1010         }
1011 
1012         HashMap retval = new HashMap(flavors.length, 1.0f);
1013         for (int i = 0; i < flavors.length; i++) {
1014             List natives = getNativesForFlavor(flavors[i]);
1015             String nat = (natives.isEmpty()) ? null : (String)natives.get(0);
1016             retval.put(flavors[i], nat);
1017         }
1018 
1019         return retval;
1020     }
1021 
1022     /**
1023      * Returns a <code>Map</code> of the specified <code>String</code> natives
1024      * to their most preferred <code>DataFlavor</code>. Each
1025      * <code>DataFlavor</code> value will be the same as the first
1026      * <code>DataFlavor</code> in the List returned by
1027      * <code>getFlavorsForNative</code> for the specified native.
1028      * <p>
1029      * If a specified native is previously unknown to the data transfer
1030      * subsystem, and that native has been properly encoded, then invoking this
1031      * method will establish a mapping in both directions between the specified
1032      * native and a <code>DataFlavor</code> whose MIME type is a decoded
1033      * version of the native.
1034      *
1035      * @param natives an array of <code>String</code>s which will be the
1036      *        key set of the returned <code>Map</code>. If <code>null</code> is
1037      *        specified, a mapping of all supported <code>String</code> natives
1038      *        to their most preferred <code>DataFlavor</code>s will be
1039      *        returned.
1040      * @return a <code>java.util.Map</code> of <code>String</code> natives to
1041      *         <code>DataFlavor</code>s
1042      *
1043      * @see #getFlavorsForNative
1044      * @see #encodeJavaMIMEType
1045      */
1046     public synchronized Map<String,DataFlavor>
1047         getFlavorsForNatives(String[] natives)
1048     {
1049         // Use getFlavorsForNative to generate extra flavors for text natives
1050 
1051         if (natives == null) {
1052             List native_list = getNativesForFlavor(null);
1053             natives = new String[native_list.size()];
1054             native_list.toArray(natives);
1055         }
1056 
1057         HashMap retval = new HashMap(natives.length, 1.0f);
1058         for (int i = 0; i < natives.length; i++) {
1059             List flavors = getFlavorsForNative(natives[i]);
1060             DataFlavor flav = (flavors.isEmpty())
1061                 ? null : (DataFlavor)flavors.get(0);
1062             retval.put(natives[i], flav);
1063         }
1064 
1065         return retval;
1066     }
1067 
1068     /**
1069      * Adds a mapping from the specified <code>DataFlavor</code> (and all
1070      * <code>DataFlavor</code>s equal to the specified <code>DataFlavor</code>)
1071      * to the specified <code>String</code> native.
1072      * Unlike <code>getNativesForFlavor</code>, the mapping will only be
1073      * established in one direction, and the native will not be encoded. To
1074      * establish a two-way mapping, call
1075      * <code>addFlavorForUnencodedNative</code> as well. The new mapping will
1076      * be of lower priority than any existing mapping.
1077      * This method has no effect if a mapping from the specified or equal
1078      * <code>DataFlavor</code> to the specified <code>String</code> native
1079      * already exists.
1080      *
1081      * @param flav the <code>DataFlavor</code> key for the mapping
1082      * @param nat the <code>String</code> native value for the mapping
1083      * @throws NullPointerException if flav or nat is <code>null</code>
1084      *
1085      * @see #addFlavorForUnencodedNative
1086      * @since 1.4
1087      */
1088     public synchronized void addUnencodedNativeForFlavor(DataFlavor flav,
1089                                                          String nat) {
1090         if (flav == null || nat == null) {
1091             throw new NullPointerException("null arguments not permitted");
1092         }
1093 
1094         List natives = (List)getFlavorToNative().get(flav);
1095         if (natives == null) {
1096             natives = new ArrayList(1);
1097             getFlavorToNative().put(flav, natives);
1098         } else if (natives.contains(nat)) {
1099             return;
1100         }
1101         natives.add(nat);
1102         getNativesForFlavorCache.remove(flav);
1103         getNativesForFlavorCache.remove(null);
1104     }
1105 
1106     /**
1107      * Discards the current mappings for the specified <code>DataFlavor</code>
1108      * and all <code>DataFlavor</code>s equal to the specified
1109      * <code>DataFlavor</code>, and creates new mappings to the
1110      * specified <code>String</code> natives.
1111      * Unlike <code>getNativesForFlavor</code>, the mappings will only be
1112      * established in one direction, and the natives will not be encoded. To
1113      * establish two-way mappings, call <code>setFlavorsForNative</code>
1114      * as well. The first native in the array will represent the highest
1115      * priority mapping. Subsequent natives will represent mappings of
1116      * decreasing priority.
1117      * <p>
1118      * If the array contains several elements that reference equal
1119      * <code>String</code> natives, this method will establish new mappings
1120      * for the first of those elements and ignore the rest of them.
1121      * <p>
1122      * It is recommended that client code not reset mappings established by the
1123      * data transfer subsystem. This method should only be used for
1124      * application-level mappings.
1125      *
1126      * @param flav the <code>DataFlavor</code> key for the mappings
1127      * @param natives the <code>String</code> native values for the mappings
1128      * @throws NullPointerException if flav or natives is <code>null</code>
1129      *         or if natives contains <code>null</code> elements
1130      *
1131      * @see #setFlavorsForNative
1132      * @since 1.4
1133      */
1134     public synchronized void setNativesForFlavor(DataFlavor flav,
1135                                                  String[] natives) {
1136         if (flav == null || natives == null) {
1137             throw new NullPointerException("null arguments not permitted");
1138         }
1139 
1140         getFlavorToNative().remove(flav);
1141         for (int i = 0; i < natives.length; i++) {
1142             addUnencodedNativeForFlavor(flav, natives[i]);
1143         }
1144         disabledMappingGenerationKeys.add(flav);
1145         // Clear the cache to handle the case of empty natives.
1146         getNativesForFlavorCache.remove(flav);
1147         getNativesForFlavorCache.remove(null);
1148     }
1149 
1150     /**
1151      * Adds a mapping from a single <code>String</code> native to a single
1152      * <code>DataFlavor</code>. Unlike <code>getFlavorsForNative</code>, the
1153      * mapping will only be established in one direction, and the native will
1154      * not be encoded. To establish a two-way mapping, call
1155      * <code>addUnencodedNativeForFlavor</code> as well. The new mapping will
1156      * be of lower priority than any existing mapping.
1157      * This method has no effect if a mapping from the specified
1158      * <code>String</code> native to the specified or equal
1159      * <code>DataFlavor</code> already exists.
1160      *
1161      * @param nat the <code>String</code> native key for the mapping
1162      * @param flav the <code>DataFlavor</code> value for the mapping
1163      * @throws NullPointerException if nat or flav is <code>null</code>
1164      *
1165      * @see #addUnencodedNativeForFlavor
1166      * @since 1.4
1167      */
1168     public synchronized void addFlavorForUnencodedNative(String nat,
1169                                                          DataFlavor flav) {
1170         if (nat == null || flav == null) {
1171             throw new NullPointerException("null arguments not permitted");
1172         }
1173 
1174         List flavors = (List)getNativeToFlavor().get(nat);
1175         if (flavors == null) {
1176             flavors = new ArrayList(1);
1177             getNativeToFlavor().put(nat, flavors);
1178         } else if (flavors.contains(flav)) {
1179             return;
1180         }
1181         flavors.add(flav);
1182         getFlavorsForNativeCache.remove(nat);
1183         getFlavorsForNativeCache.remove(null);
1184     }
1185 
1186     /**
1187      * Discards the current mappings for the specified <code>String</code>
1188      * native, and creates new mappings to the specified
1189      * <code>DataFlavor</code>s. Unlike <code>getFlavorsForNative</code>, the
1190      * mappings will only be established in one direction, and the natives need
1191      * not be encoded. To establish two-way mappings, call
1192      * <code>setNativesForFlavor</code> as well. The first
1193      * <code>DataFlavor</code> in the array will represent the highest priority
1194      * mapping. Subsequent <code>DataFlavor</code>s will represent mappings of
1195      * decreasing priority.
1196      * <p>
1197      * If the array contains several elements that reference equal
1198      * <code>DataFlavor</code>s, this method will establish new mappings
1199      * for the first of those elements and ignore the rest of them.
1200      * <p>
1201      * It is recommended that client code not reset mappings established by the
1202      * data transfer subsystem. This method should only be used for
1203      * application-level mappings.
1204      *
1205      * @param nat the <code>String</code> native key for the mappings
1206      * @param flavors the <code>DataFlavor</code> values for the mappings
1207      * @throws NullPointerException if nat or flavors is <code>null</code>
1208      *         or if flavors contains <code>null</code> elements
1209      *
1210      * @see #setNativesForFlavor
1211      * @since 1.4
1212      */
1213     public synchronized void setFlavorsForNative(String nat,
1214                                                  DataFlavor[] flavors) {
1215         if (nat == null || flavors == null) {
1216             throw new NullPointerException("null arguments not permitted");
1217         }
1218 
1219         getNativeToFlavor().remove(nat);
1220         for (int i = 0; i < flavors.length; i++) {
1221             addFlavorForUnencodedNative(nat, flavors[i]);
1222         }
1223         disabledMappingGenerationKeys.add(nat);
1224         // Clear the cache to handle the case of empty flavors.
1225         getFlavorsForNativeCache.remove(nat);
1226         getFlavorsForNativeCache.remove(null);
1227     }
1228 
1229     /**
1230      * Encodes a MIME type for use as a <code>String</code> native. The format
1231      * of an encoded representation of a MIME type is implementation-dependent.
1232      * The only restrictions are:
1233      * <ul>
1234      * <li>The encoded representation is <code>null</code> if and only if the
1235      * MIME type <code>String</code> is <code>null</code>.</li>
1236      * <li>The encoded representations for two non-<code>null</code> MIME type
1237      * <code>String</code>s are equal if and only if these <code>String</code>s
1238      * are equal according to <code>String.equals(Object)</code>.</li>
1239      * </ul>
1240      * <p>
1241      * The reference implementation of this method returns the specified MIME
1242      * type <code>String</code> prefixed with <code>JAVA_DATAFLAVOR:</code>.
1243      *
1244      * @param mimeType the MIME type to encode
1245      * @return the encoded <code>String</code>, or <code>null</code> if
1246      *         mimeType is <code>null</code>
1247      */
1248     public static String encodeJavaMIMEType(String mimeType) {
1249         return (mimeType != null)
1250             ? JavaMIME + mimeType
1251             : null;
1252     }
1253 
1254     /**
1255      * Encodes a <code>DataFlavor</code> for use as a <code>String</code>
1256      * native. The format of an encoded <code>DataFlavor</code> is
1257      * implementation-dependent. The only restrictions are:
1258      * <ul>
1259      * <li>The encoded representation is <code>null</code> if and only if the
1260      * specified <code>DataFlavor</code> is <code>null</code> or its MIME type
1261      * <code>String</code> is <code>null</code>.</li>
1262      * <li>The encoded representations for two non-<code>null</code>
1263      * <code>DataFlavor</code>s with non-<code>null</code> MIME type
1264      * <code>String</code>s are equal if and only if the MIME type
1265      * <code>String</code>s of these <code>DataFlavor</code>s are equal
1266      * according to <code>String.equals(Object)</code>.</li>
1267      * </ul>
1268      * <p>
1269      * The reference implementation of this method returns the MIME type
1270      * <code>String</code> of the specified <code>DataFlavor</code> prefixed
1271      * with <code>JAVA_DATAFLAVOR:</code>.
1272      *
1273      * @param flav the <code>DataFlavor</code> to encode
1274      * @return the encoded <code>String</code>, or <code>null</code> if
1275      *         flav is <code>null</code> or has a <code>null</code> MIME type
1276      */
1277     public static String encodeDataFlavor(DataFlavor flav) {
1278         return (flav != null)
1279             ? SystemFlavorMap.encodeJavaMIMEType(flav.getMimeType())
1280             : null;
1281     }
1282 
1283     /**
1284      * Returns whether the specified <code>String</code> is an encoded Java
1285      * MIME type.
1286      *
1287      * @param str the <code>String</code> to test
1288      * @return <code>true</code> if the <code>String</code> is encoded;
1289      *         <code>false</code> otherwise
1290      */
1291     public static boolean isJavaMIMEType(String str) {
1292         return (str != null && str.startsWith(JavaMIME, 0));
1293     }
1294 
1295     /**
1296      * Decodes a <code>String</code> native for use as a Java MIME type.
1297      *
1298      * @param nat the <code>String</code> to decode
1299      * @return the decoded Java MIME type, or <code>null</code> if nat is not
1300      *         an encoded <code>String</code> native
1301      */
1302     public static String decodeJavaMIMEType(String nat) {
1303         return (isJavaMIMEType(nat))
1304             ? nat.substring(JavaMIME.length(), nat.length()).trim()
1305             : null;
1306     }
1307 
1308     /**
1309      * Decodes a <code>String</code> native for use as a
1310      * <code>DataFlavor</code>.
1311      *
1312      * @param nat the <code>String</code> to decode
1313      * @return the decoded <code>DataFlavor</code>, or <code>null</code> if
1314      *         nat is not an encoded <code>String</code> native
1315      */
1316     public static DataFlavor decodeDataFlavor(String nat)
1317         throws ClassNotFoundException
1318     {
1319         String retval_str = SystemFlavorMap.decodeJavaMIMEType(nat);
1320         return (retval_str != null)
1321             ? new DataFlavor(retval_str)
1322             : null;
1323     }














1324 }
--- EOF ---