Java tutorial
/* * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.awt.datatransfer; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.lang.ref.SoftReference; import java.security.AccessController; import java.security.PrivilegedAction; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Set; import sun.datatransfer.DataFlavorUtil; import sun.datatransfer.DesktopDatatransferService; /** * The SystemFlavorMap is a configurable map between "natives" (Strings), which * correspond to platform-specific data formats, and "flavors" (DataFlavors), * which correspond to platform-independent MIME types. This mapping is used by * the data transfer subsystem to transfer data between Java and native * applications, and between Java applications in separate VMs. * * @since 1.2 */ public final class SystemFlavorMap implements FlavorMap, FlavorTable { /** * Constant prefix used to tag Java types converted to native platform type. */ private static String JavaMIME = "JAVA_DATAFLAVOR:"; private static final Object FLAVOR_MAP_KEY = new Object(); /** * The list of valid, decoded text flavor representation classes, in order * from best to worst. */ private static final String[] UNICODE_TEXT_CLASSES = { "java.io.Reader", "java.lang.String", "java.nio.CharBuffer", "\"[C\"" }; /** * The list of valid, encoded text flavor representation classes, in order * from best to worst. */ private static final String[] ENCODED_TEXT_CLASSES = { "java.io.InputStream", "java.nio.ByteBuffer", "\"[B\"" }; /** * A String representing text/plain MIME type. */ private static final String TEXT_PLAIN_BASE_TYPE = "text/plain"; /** * A String representing text/html MIME type. */ private static final String HTML_TEXT_BASE_TYPE = "text/html"; /** * Maps native Strings to Lists of DataFlavors (or base type Strings for * text DataFlavors). * <p> * Do not use the field directly, use {@link #getNativeToFlavor} instead. */ private final Map<String, LinkedHashSet<DataFlavor>> nativeToFlavor = new HashMap<>(); /** * Accessor to nativeToFlavor map. Since we use lazy initialization we must * use this accessor instead of direct access to the field which may not be * initialized yet. This method will initialize the field if needed. * * @return nativeToFlavor */ private Map<String, LinkedHashSet<DataFlavor>> getNativeToFlavor() { if (!isMapInitialized) { initSystemFlavorMap(); } return nativeToFlavor; } /** * Maps DataFlavors (or base type Strings for text DataFlavors) to Lists of * native Strings. * <p> * Do not use the field directly, use {@link #getFlavorToNative} instead. */ private final Map<DataFlavor, LinkedHashSet<String>> flavorToNative = new HashMap<>(); /** * Accessor to flavorToNative map. Since we use lazy initialization we must * use this accessor instead of direct access to the field which may not be * initialized yet. This method will initialize the field if needed. * * @return flavorToNative */ private synchronized Map<DataFlavor, LinkedHashSet<String>> getFlavorToNative() { if (!isMapInitialized) { initSystemFlavorMap(); } return flavorToNative; } /** * Maps a text DataFlavor primary mime-type to the native. Used only to * store standard mappings registered in the {@code flavormap.properties}. * <p> * Do not use this field directly, use {@link #getTextTypeToNative} instead. */ private Map<String, LinkedHashSet<String>> textTypeToNative = new HashMap<>(); /** * Shows if the object has been initialized. */ private boolean isMapInitialized = false; /** * An accessor to textTypeToNative map. Since we use lazy initialization we * must use this accessor instead of direct access to the field which may * not be initialized yet. This method will initialize the field if needed. * * @return textTypeToNative */ private synchronized Map<String, LinkedHashSet<String>> getTextTypeToNative() { if (!isMapInitialized) { initSystemFlavorMap(); // From this point the map should not be modified textTypeToNative = Collections.unmodifiableMap(textTypeToNative); } return textTypeToNative; } /** * Caches the result of getNativesForFlavor(). Maps DataFlavors to * SoftReferences which reference LinkedHashSet of String natives. */ private final SoftCache<DataFlavor, String> nativesForFlavorCache = new SoftCache<>(); /** * Caches the result getFlavorsForNative(). Maps String natives to * SoftReferences which reference LinkedHashSet of DataFlavors. */ private final SoftCache<String, DataFlavor> flavorsForNativeCache = new SoftCache<>(); /** * Dynamic mapping generation used for text mappings should not be applied * to the DataFlavors and String natives for which the mappings have been * explicitly specified with {@link #setFlavorsForNative} or * {@link #setNativesForFlavor}. This keeps all such keys. */ private Set<Object> disabledMappingGenerationKeys = new HashSet<>(); /** * Returns the default FlavorMap for this thread's ClassLoader. * * @return the default FlavorMap for this thread's ClassLoader */ public static FlavorMap getDefaultFlavorMap() { return DataFlavorUtil.getDesktopService().getFlavorMap(SystemFlavorMap::new); } private SystemFlavorMap() { } /** * Initializes a SystemFlavorMap by reading {@code flavormap.properties}. * For thread-safety must be called under lock on {@code this}. */ private void initSystemFlavorMap() { if (isMapInitialized) { return; } isMapInitialized = true; InputStream is = AccessController.doPrivileged((PrivilegedAction<InputStream>) () -> { return SystemFlavorMap.class.getResourceAsStream("/sun/datatransfer/resources/flavormap.properties"); }); if (is == null) { throw new InternalError("Default flavor mapping not found"); } try (InputStreamReader isr = new InputStreamReader(is); BufferedReader reader = new BufferedReader(isr)) { String line; while ((line = reader.readLine()) != null) { line = line.trim(); if (line.startsWith("#") || line.isEmpty()) continue; while (line.endsWith("\\")) { line = line.substring(0, line.length() - 1) + reader.readLine().trim(); } int delimiterPosition = line.indexOf('='); String key = line.substring(0, delimiterPosition).replace("\\ ", " "); String[] values = line.substring(delimiterPosition + 1, line.length()).split(","); for (String value : values) { try { value = loadConvert(value); MimeType mime = new MimeType(value); if ("text".equals(mime.getPrimaryType())) { String charset = mime.getParameter("charset"); if (DataFlavorUtil.doesSubtypeSupportCharset(mime.getSubType(), charset)) { // We need to store the charset and eoln // parameters, if any, so that the // DataTransferer will have this information // for conversion into the native format. DesktopDatatransferService desktopService = DataFlavorUtil.getDesktopService(); if (desktopService.isDesktopPresent()) { desktopService.registerTextFlavorProperties(key, charset, mime.getParameter("eoln"), mime.getParameter("terminators")); } } // But don't store any of these parameters in the // DataFlavor itself for any text natives (even // non-charset ones). The SystemFlavorMap will // synthesize the appropriate mappings later. mime.removeParameter("charset"); mime.removeParameter("class"); mime.removeParameter("eoln"); mime.removeParameter("terminators"); value = mime.toString(); } } catch (MimeTypeParseException e) { e.printStackTrace(); continue; } DataFlavor flavor; try { flavor = new DataFlavor(value); } catch (Exception e) { try { flavor = new DataFlavor(value, null); } catch (Exception ee) { ee.printStackTrace(); continue; } } final LinkedHashSet<DataFlavor> dfs = new LinkedHashSet<>(); dfs.add(flavor); if ("text".equals(flavor.getPrimaryType())) { dfs.addAll(convertMimeTypeToDataFlavors(value)); store(flavor.mimeType.getBaseType(), key, getTextTypeToNative()); } for (DataFlavor df : dfs) { store(df, key, getFlavorToNative()); store(key, df, getNativeToFlavor()); } } } } catch (IOException e) { throw new InternalError("Error reading default flavor mapping", e); } } // Copied from java.util.Properties private static String loadConvert(String theString) { char aChar; int len = theString.length(); StringBuilder outBuffer = new StringBuilder(len); for (int x = 0; x < len;) { aChar = theString.charAt(x++); if (aChar == '\\') { aChar = theString.charAt(x++); if (aChar == 'u') { // Read the xxxx int value = 0; for (int i = 0; i < 4; i++) { aChar = theString.charAt(x++); switch (aChar) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': { value = (value << 4) + aChar - '0'; break; } case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': { value = (value << 4) + 10 + aChar - 'a'; break; } case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': { value = (value << 4) + 10 + aChar - 'A'; break; } default: { throw new IllegalArgumentException("Malformed \\uxxxx encoding."); } } } outBuffer.append((char) value); } else { if (aChar == 't') { aChar = '\t'; } else if (aChar == 'r') { aChar = '\r'; } else if (aChar == 'n') { aChar = '\n'; } else if (aChar == 'f') { aChar = '\f'; } outBuffer.append(aChar); } } else { outBuffer.append(aChar); } } return outBuffer.toString(); } /** * Stores the listed object under the specified hash key in map. Unlike a * standard map, the listed object will not replace any object already at * the appropriate Map location, but rather will be appended to a List * stored in that location. */ private <H, L> void store(H hashed, L listed, Map<H, LinkedHashSet<L>> map) { LinkedHashSet<L> list = map.get(hashed); if (list == null) { list = new LinkedHashSet<>(1); map.put(hashed, list); } if (!list.contains(listed)) { list.add(listed); } } /** * Semantically equivalent to 'nativeToFlavor.get(nat)'. This method handles * the case where 'nat' is not found in 'nativeToFlavor'. In that case, a * new DataFlavor is synthesized, stored, and returned, if and only if the * specified native is encoded as a Java MIME type. */ private LinkedHashSet<DataFlavor> nativeToFlavorLookup(String nat) { LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(nat); if (nat != null && !disabledMappingGenerationKeys.contains(nat)) { DesktopDatatransferService desktopService = DataFlavorUtil.getDesktopService(); if (desktopService.isDesktopPresent()) { LinkedHashSet<DataFlavor> platformFlavors = desktopService.getPlatformMappingsForNative(nat); if (!platformFlavors.isEmpty()) { if (flavors != null) { // Prepending the platform-specific mappings ensures // that the flavors added with // addFlavorForUnencodedNative() are at the end of // list. platformFlavors.addAll(flavors); } flavors = platformFlavors; } } } if (flavors == null && isJavaMIMEType(nat)) { String decoded = decodeJavaMIMEType(nat); DataFlavor flavor = null; try { flavor = new DataFlavor(decoded); } catch (Exception e) { System.err.println("Exception \"" + e.getClass().getName() + ": " + e.getMessage() + "\"while constructing DataFlavor for: " + decoded); } if (flavor != null) { flavors = new LinkedHashSet<>(1); getNativeToFlavor().put(nat, flavors); flavors.add(flavor); flavorsForNativeCache.remove(nat); LinkedHashSet<String> natives = getFlavorToNative().get(flavor); if (natives == null) { natives = new LinkedHashSet<>(1); getFlavorToNative().put(flavor, natives); } natives.add(nat); nativesForFlavorCache.remove(flavor); } } return (flavors != null) ? flavors : new LinkedHashSet<>(0); } /** * Semantically equivalent to 'flavorToNative.get(flav)'. This method * handles the case where 'flav' is not found in 'flavorToNative' depending * on the value of passes 'synthesize' parameter. If 'synthesize' is * SYNTHESIZE_IF_NOT_FOUND a native is synthesized, stored, and returned by * encoding the DataFlavor's MIME type. Otherwise an empty List is returned * and 'flavorToNative' remains unaffected. */ private LinkedHashSet<String> flavorToNativeLookup(final DataFlavor flav, final boolean synthesize) { LinkedHashSet<String> natives = getFlavorToNative().get(flav); if (flav != null && !disabledMappingGenerationKeys.contains(flav)) { DesktopDatatransferService desktopService = DataFlavorUtil.getDesktopService(); if (desktopService.isDesktopPresent()) { LinkedHashSet<String> platformNatives = desktopService.getPlatformMappingsForFlavor(flav); if (!platformNatives.isEmpty()) { if (natives != null) { // Prepend the platform-specific mappings to ensure // that the natives added with // addUnencodedNativeForFlavor() are at the end of // list. platformNatives.addAll(natives); } natives = platformNatives; } } } if (natives == null) { if (synthesize) { String encoded = encodeDataFlavor(flav); natives = new LinkedHashSet<>(1); getFlavorToNative().put(flav, natives); natives.add(encoded); LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(encoded); if (flavors == null) { flavors = new LinkedHashSet<>(1); getNativeToFlavor().put(encoded, flavors); } flavors.add(flav); nativesForFlavorCache.remove(flav); flavorsForNativeCache.remove(encoded); } else { natives = new LinkedHashSet<>(0); } } return new LinkedHashSet<>(natives); } /** * Returns a {@code List} of {@code String} natives to which the specified * {@code DataFlavor} can be translated by the data transfer subsystem. The * {@code List} will be sorted from best native to worst. That is, the first * native will best reflect data in the specified flavor to the underlying * native platform. * <p> * If the specified {@code DataFlavor} is previously unknown to the data * transfer subsystem and the data transfer subsystem is unable to translate * this {@code DataFlavor} to any existing native, then invoking this method * will establish a mapping in both directions between the specified * {@code DataFlavor} and an encoded version of its MIME type as its native. * * @param flav the {@code DataFlavor} whose corresponding natives should be * returned. If {@code null} is specified, all natives currently * known to the data transfer subsystem are returned in a * non-deterministic order. * @return a {@code java.util.List} of {@code java.lang.String} objects * which are platform-specific representations of platform-specific * data formats * @see #encodeDataFlavor * @since 1.4 */ @Override public synchronized List<String> getNativesForFlavor(DataFlavor flav) { LinkedHashSet<String> retval = nativesForFlavorCache.check(flav); if (retval != null) { return new ArrayList<>(retval); } if (flav == null) { retval = new LinkedHashSet<>(getNativeToFlavor().keySet()); } else if (disabledMappingGenerationKeys.contains(flav)) { // In this case we shouldn't synthesize a native for this flavor, // since its mappings were explicitly specified. retval = flavorToNativeLookup(flav, false); } else if (DataFlavorUtil.isFlavorCharsetTextType(flav)) { retval = new LinkedHashSet<>(0); // For text/* flavors, flavor-to-native mappings specified in // flavormap.properties are stored per flavor's base type. if ("text".equals(flav.getPrimaryType())) { LinkedHashSet<String> textTypeNatives = getTextTypeToNative().get(flav.mimeType.getBaseType()); if (textTypeNatives != null) { retval.addAll(textTypeNatives); } } // Also include text/plain natives, but don't duplicate Strings LinkedHashSet<String> textTypeNatives = getTextTypeToNative().get(TEXT_PLAIN_BASE_TYPE); if (textTypeNatives != null) { retval.addAll(textTypeNatives); } if (retval.isEmpty()) { retval = flavorToNativeLookup(flav, true); } else { // In this branch it is guaranteed that natives explicitly // listed for flav's MIME type were added with // addUnencodedNativeForFlavor(), so they have lower priority. retval.addAll(flavorToNativeLookup(flav, false)); } } else if (DataFlavorUtil.isFlavorNoncharsetTextType(flav)) { retval = getTextTypeToNative().get(flav.mimeType.getBaseType()); if (retval == null || retval.isEmpty()) { retval = flavorToNativeLookup(flav, true); } else { // In this branch it is guaranteed that natives explicitly // listed for flav's MIME type were added with // addUnencodedNativeForFlavor(), so they have lower priority. retval.addAll(flavorToNativeLookup(flav, false)); } } else { retval = flavorToNativeLookup(flav, true); } nativesForFlavorCache.put(flav, retval); // Create a copy, because client code can modify the returned list. return new ArrayList<>(retval); } /** * Returns a {@code List} of {@code DataFlavor}s to which the specified * {@code String} native can be translated by the data transfer subsystem. * The {@code List} will be sorted from best {@code DataFlavor} to worst. * That is, the first {@code DataFlavor} will best reflect data in the * specified native to a Java application. * <p> * If the specified native is previously unknown to the data transfer * subsystem, and that native has been properly encoded, then invoking this * method will establish a mapping in both directions between the specified * native and a {@code DataFlavor} whose MIME type is a decoded version of * the native. * <p> * If the specified native is not a properly encoded native and the mappings * for this native have not been altered with {@code setFlavorsForNative}, * then the contents of the {@code List} is platform dependent, but * {@code null} cannot be returned. * * @param nat the native whose corresponding {@code DataFlavor}s should be * returned. If {@code null} is specified, all {@code DataFlavor}s * currently known to the data transfer subsystem are returned in a * non-deterministic order. * @return a {@code java.util.List} of {@code DataFlavor} objects into which * platform-specific data in the specified, platform-specific native * can be translated * @see #encodeJavaMIMEType * @since 1.4 */ @Override public synchronized List<DataFlavor> getFlavorsForNative(String nat) { LinkedHashSet<DataFlavor> returnValue = flavorsForNativeCache.check(nat); if (returnValue != null) { return new ArrayList<>(returnValue); } else { returnValue = new LinkedHashSet<>(); } if (nat == null) { for (String n : getNativesForFlavor(null)) { returnValue.addAll(getFlavorsForNative(n)); } } else { final LinkedHashSet<DataFlavor> flavors = nativeToFlavorLookup(nat); if (disabledMappingGenerationKeys.contains(nat)) { return new ArrayList<>(flavors); } final LinkedHashSet<DataFlavor> flavorsWithSynthesized = nativeToFlavorLookup(nat); for (DataFlavor df : flavorsWithSynthesized) { returnValue.add(df); if ("text".equals(df.getPrimaryType())) { String baseType = df.mimeType.getBaseType(); returnValue.addAll(convertMimeTypeToDataFlavors(baseType)); } } } flavorsForNativeCache.put(nat, returnValue); return new ArrayList<>(returnValue); } @SuppressWarnings("deprecation") private static Set<DataFlavor> convertMimeTypeToDataFlavors(final String baseType) { final Set<DataFlavor> returnValue = new LinkedHashSet<>(); String subType = null; try { final MimeType mimeType = new MimeType(baseType); subType = mimeType.getSubType(); } catch (MimeTypeParseException mtpe) { // Cannot happen, since we checked all mappings // on load from flavormap.properties. } if (DataFlavorUtil.doesSubtypeSupportCharset(subType, null)) { if (TEXT_PLAIN_BASE_TYPE.equals(baseType)) { returnValue.add(DataFlavor.stringFlavor); } for (String unicodeClassName : UNICODE_TEXT_CLASSES) { final String mimeType = baseType + ";charset=Unicode;class=" + unicodeClassName; final LinkedHashSet<String> mimeTypes = handleHtmlMimeTypes(baseType, mimeType); for (String mt : mimeTypes) { DataFlavor toAdd = null; try { toAdd = new DataFlavor(mt); } catch (ClassNotFoundException cannotHappen) { } returnValue.add(toAdd); } } for (String charset : DataFlavorUtil.standardEncodings()) { for (String encodedTextClass : ENCODED_TEXT_CLASSES) { final String mimeType = baseType + ";charset=" + charset + ";class=" + encodedTextClass; final LinkedHashSet<String> mimeTypes = handleHtmlMimeTypes(baseType, mimeType); for (String mt : mimeTypes) { DataFlavor df = null; try { df = new DataFlavor(mt); // Check for equality to plainTextFlavor so // that we can ensure that the exact charset of // plainTextFlavor, not the canonical charset // or another equivalent charset with a // different name, is used. if (df.equals(DataFlavor.plainTextFlavor)) { df = DataFlavor.plainTextFlavor; } } catch (ClassNotFoundException cannotHappen) { } returnValue.add(df); } } } if (TEXT_PLAIN_BASE_TYPE.equals(baseType)) { returnValue.add(DataFlavor.plainTextFlavor); } } else { // Non-charset text natives should be treated as // opaque, 8-bit data in any of its various // representations. for (String encodedTextClassName : ENCODED_TEXT_CLASSES) { DataFlavor toAdd = null; try { toAdd = new DataFlavor(baseType + ";class=" + encodedTextClassName); } catch (ClassNotFoundException cannotHappen) { } returnValue.add(toAdd); } } return returnValue; } private static final String[] htmlDocumentTypes = new String[] { "all", "selection", "fragment" }; private static LinkedHashSet<String> handleHtmlMimeTypes(String baseType, String mimeType) { LinkedHashSet<String> returnValues = new LinkedHashSet<>(); if (HTML_TEXT_BASE_TYPE.equals(baseType)) { for (String documentType : htmlDocumentTypes) { returnValues.add(mimeType + ";document=" + documentType); } } else { returnValues.add(mimeType); } return returnValues; } /** * Returns a {@code Map} of the specified {@code DataFlavor}s to their most * preferred {@code String} native. Each native value will be the same as * the first native in the List returned by {@code getNativesForFlavor} for * the specified flavor. * <p> * If a specified {@code DataFlavor} is previously unknown to the data * transfer subsystem, then invoking this method will establish a mapping in * both directions between the specified {@code DataFlavor} and an encoded * version of its MIME type as its native. * * @param flavors an array of {@code DataFlavor}s which will be the key set * of the returned {@code Map}. If {@code null} is specified, a * mapping of all {@code DataFlavor}s known to the data transfer * subsystem to their most preferred {@code String} natives will be * returned. * @return a {@code java.util.Map} of {@code DataFlavor}s to {@code String} * natives * @see #getNativesForFlavor * @see #encodeDataFlavor */ @Override public synchronized Map<DataFlavor, String> getNativesForFlavors(DataFlavor[] flavors) { // Use getNativesForFlavor to generate extra natives for text flavors // and stringFlavor if (flavors == null) { List<DataFlavor> flavor_list = getFlavorsForNative(null); flavors = new DataFlavor[flavor_list.size()]; flavor_list.toArray(flavors); } Map<DataFlavor, String> retval = new HashMap<>(flavors.length, 1.0f); for (DataFlavor flavor : flavors) { List<String> natives = getNativesForFlavor(flavor); String nat = (natives.isEmpty()) ? null : natives.get(0); retval.put(flavor, nat); } return retval; } /** * Returns a {@code Map} of the specified {@code String} natives to their * most preferred {@code DataFlavor}. Each {@code DataFlavor} value will be * the same as the first {@code DataFlavor} in the List returned by * {@code getFlavorsForNative} for the specified native. * <p> * If a specified native is previously unknown to the data transfer * subsystem, and that native has been properly encoded, then invoking this * method will establish a mapping in both directions between the specified * native and a {@code DataFlavor} whose MIME type is a decoded version of * the native. * * @param natives an array of {@code String}s which will be the key set of * the returned {@code Map}. If {@code null} is specified, a mapping * of all supported {@code String} natives to their most preferred * {@code DataFlavor}s will be returned. * @return a {@code java.util.Map} of {@code String} natives to * {@code DataFlavor}s * @see #getFlavorsForNative * @see #encodeJavaMIMEType */ @Override public synchronized Map<String, DataFlavor> getFlavorsForNatives(String[] natives) { // Use getFlavorsForNative to generate extra flavors for text natives if (natives == null) { List<String> nativesList = getNativesForFlavor(null); natives = new String[nativesList.size()]; nativesList.toArray(natives); } Map<String, DataFlavor> retval = new HashMap<>(natives.length, 1.0f); for (String aNative : natives) { List<DataFlavor> flavors = getFlavorsForNative(aNative); DataFlavor flav = (flavors.isEmpty()) ? null : flavors.get(0); retval.put(aNative, flav); } return retval; } /** * Adds a mapping from the specified {@code DataFlavor} (and all * {@code DataFlavor}s equal to the specified {@code DataFlavor}) to the * specified {@code String} native. Unlike {@code getNativesForFlavor}, the * mapping will only be established in one direction, and the native will * not be encoded. To establish a two-way mapping, call * {@code addFlavorForUnencodedNative} as well. The new mapping will be of * lower priority than any existing mapping. This method has no effect if a * mapping from the specified or equal {@code DataFlavor} to the specified * {@code String} native already exists. * * @param flav the {@code DataFlavor} key for the mapping * @param nat the {@code String} native value for the mapping * @throws NullPointerException if flav or nat is {@code null} * @see #addFlavorForUnencodedNative * @since 1.4 */ public synchronized void addUnencodedNativeForFlavor(DataFlavor flav, String nat) { Objects.requireNonNull(nat, "Null native not permitted"); Objects.requireNonNull(flav, "Null flavor not permitted"); LinkedHashSet<String> natives = getFlavorToNative().get(flav); if (natives == null) { natives = new LinkedHashSet<>(1); getFlavorToNative().put(flav, natives); } natives.add(nat); nativesForFlavorCache.remove(flav); } /** * Discards the current mappings for the specified {@code DataFlavor} and * all {@code DataFlavor}s equal to the specified {@code DataFlavor}, and * creates new mappings to the specified {@code String} natives. Unlike * {@code getNativesForFlavor}, the mappings will only be established in one * direction, and the natives will not be encoded. To establish two-way * mappings, call {@code setFlavorsForNative} as well. The first native in * the array will represent the highest priority mapping. Subsequent natives * will represent mappings of decreasing priority. * <p> * If the array contains several elements that reference equal * {@code String} natives, this method will establish new mappings for the * first of those elements and ignore the rest of them. * <p> * It is recommended that client code not reset mappings established by the * data transfer subsystem. This method should only be used for * application-level mappings. * * @param flav the {@code DataFlavor} key for the mappings * @param natives the {@code String} native values for the mappings * @throws NullPointerException if flav or natives is {@code null} or if * natives contains {@code null} elements * @see #setFlavorsForNative * @since 1.4 */ public synchronized void setNativesForFlavor(DataFlavor flav, String[] natives) { Objects.requireNonNull(natives, "Null natives not permitted"); Objects.requireNonNull(flav, "Null flavors not permitted"); getFlavorToNative().remove(flav); for (String aNative : natives) { addUnencodedNativeForFlavor(flav, aNative); } disabledMappingGenerationKeys.add(flav); nativesForFlavorCache.remove(flav); } /** * Adds a mapping from a single {@code String} native to a single * {@code DataFlavor}. Unlike {@code getFlavorsForNative}, the mapping will * only be established in one direction, and the native will not be encoded. * To establish a two-way mapping, call {@code addUnencodedNativeForFlavor} * as well. The new mapping will be of lower priority than any existing * mapping. This method has no effect if a mapping from the specified * {@code String} native to the specified or equal {@code DataFlavor} * already exists. * * @param nat the {@code String} native key for the mapping * @param flav the {@code DataFlavor} value for the mapping * @throws NullPointerException if {@code nat} or {@code flav} is * {@code null} * @see #addUnencodedNativeForFlavor * @since 1.4 */ public synchronized void addFlavorForUnencodedNative(String nat, DataFlavor flav) { Objects.requireNonNull(nat, "Null native not permitted"); Objects.requireNonNull(flav, "Null flavor not permitted"); LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(nat); if (flavors == null) { flavors = new LinkedHashSet<>(1); getNativeToFlavor().put(nat, flavors); } flavors.add(flav); flavorsForNativeCache.remove(nat); } /** * Discards the current mappings for the specified {@code String} native, * and creates new mappings to the specified {@code DataFlavor}s. Unlike * {@code getFlavorsForNative}, the mappings will only be established in one * direction, and the natives need not be encoded. To establish two-way * mappings, call {@code setNativesForFlavor} as well. The first * {@code DataFlavor} in the array will represent the highest priority * mapping. Subsequent {@code DataFlavor}s will represent mappings of * decreasing priority. * <p> * If the array contains several elements that reference equal * {@code DataFlavor}s, this method will establish new mappings for the * first of those elements and ignore the rest of them. * <p> * It is recommended that client code not reset mappings established by the * data transfer subsystem. This method should only be used for * application-level mappings. * * @param nat the {@code String} native key for the mappings * @param flavors the {@code DataFlavor} values for the mappings * @throws NullPointerException if {@code nat} or {@code flavors} is * {@code null} or if {@code flavors} contains {@code null} elements * @see #setNativesForFlavor * @since 1.4 */ public synchronized void setFlavorsForNative(String nat, DataFlavor[] flavors) { Objects.requireNonNull(nat, "Null native not permitted"); Objects.requireNonNull(flavors, "Null flavors not permitted"); getNativeToFlavor().remove(nat); for (DataFlavor flavor : flavors) { addFlavorForUnencodedNative(nat, flavor); } disabledMappingGenerationKeys.add(nat); flavorsForNativeCache.remove(nat); } /** * Encodes a MIME type for use as a {@code String} native. The format of an * encoded representation of a MIME type is implementation-dependent. The * only restrictions are: * <ul> * <li>The encoded representation is {@code null} if and only if the MIME * type {@code String} is {@code null}</li> * <li>The encoded representations for two non-{@code null} MIME type * {@code String}s are equal if and only if these {@code String}s are * equal according to {@code String.equals(Object)}</li> * </ul> * The reference implementation of this method returns the specified MIME * type {@code String} prefixed with {@code JAVA_DATAFLAVOR:}. * * @param mimeType the MIME type to encode * @return the encoded {@code String}, or {@code null} if {@code mimeType} * is {@code null} */ public static String encodeJavaMIMEType(String mimeType) { return (mimeType != null) ? JavaMIME + mimeType : null; } /** * Encodes a {@code DataFlavor} for use as a {@code String} native. The * format of an encoded {@code DataFlavor} is implementation-dependent. The * only restrictions are: * <ul> * <li>The encoded representation is {@code null} if and only if the * specified {@code DataFlavor} is {@code null} or its MIME type * {@code String} is {@code null}</li> * <li>The encoded representations for two non-{@code null} * {@code DataFlavor}s with non-{@code null} MIME type {@code String}s * are equal if and only if the MIME type {@code String}s of these * {@code DataFlavor}s are equal according to * {@code String.equals(Object)}</li> * </ul> * The reference implementation of this method returns the MIME type * {@code String} of the specified {@code DataFlavor} prefixed with * {@code JAVA_DATAFLAVOR:}. * * @param flav the {@code DataFlavor} to encode * @return the encoded {@code String}, or {@code null} if {@code flav} is * {@code null} or has a {@code null} MIME type */ public static String encodeDataFlavor(DataFlavor flav) { return (flav != null) ? SystemFlavorMap.encodeJavaMIMEType(flav.getMimeType()) : null; } /** * Returns whether the specified {@code String} is an encoded Java MIME * type. * * @param str the {@code String} to test * @return {@code true} if the {@code String} is encoded; {@code false} * otherwise */ public static boolean isJavaMIMEType(String str) { return (str != null && str.startsWith(JavaMIME, 0)); } /** * Decodes a {@code String} native for use as a Java MIME type. * * @param nat the {@code String} to decode * @return the decoded Java MIME type, or {@code null} if {@code nat} is not * an encoded {@code String} native */ public static String decodeJavaMIMEType(String nat) { return (isJavaMIMEType(nat)) ? nat.substring(JavaMIME.length(), nat.length()).trim() : null; } /** * Decodes a {@code String} native for use as a {@code DataFlavor}. * * @param nat the {@code String} to decode * @return the decoded {@code DataFlavor}, or {@code null} if {@code nat} is * not an encoded {@code String} native * @throws ClassNotFoundException if the class of the data flavor is not * loaded */ public static DataFlavor decodeDataFlavor(String nat) throws ClassNotFoundException { String retval_str = SystemFlavorMap.decodeJavaMIMEType(nat); return (retval_str != null) ? new DataFlavor(retval_str) : null; } private static final class SoftCache<K, V> { Map<K, SoftReference<LinkedHashSet<V>>> cache; public void put(K key, LinkedHashSet<V> value) { if (cache == null) { cache = new HashMap<>(1); } cache.put(key, new SoftReference<>(value)); } public void remove(K key) { if (cache == null) return; cache.remove(null); cache.remove(key); } public LinkedHashSet<V> check(K key) { if (cache == null) return null; SoftReference<LinkedHashSet<V>> ref = cache.get(key); if (ref != null) { return ref.get(); } return null; } } }