,code,repo_name,path,language,license,size 0,"/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * ""License""); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * ""AS IS"" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ #ifndef __MCU_STM32L0_BSP_H_ #define __MCU_STM32L0_BSP_H_ #include #include #ifdef __cplusplus extern ""C"" { #endif /** * BSP specific UART settings. */ struct stm32_uart_cfg { USART_TypeDef *suc_uart; /* UART dev registers */ volatile uint32_t *suc_rcc_reg; /* RCC register to modify */ uint32_t suc_rcc_dev; /* RCC device ID */ int8_t suc_pin_tx; /* pins for IO */ int8_t suc_pin_rx; int8_t suc_pin_rts; int8_t suc_pin_cts; uint8_t suc_pin_af; /* AF selection for this */ IRQn_Type suc_irqn; /* NVIC IRQn */ }; /* * Internal API for stm32l0xx mcu specific code. */ int hal_gpio_init_af(int pin, uint8_t af_type, enum hal_gpio_pull pull, uint8_t od); struct hal_flash; extern struct hal_flash stm32l0_flash_dev; #ifdef __cplusplus } #endif #endif /* __MCU_STM32L0_BSP_H_ */ ",mlaz/mynewt-core,hw/mcu/stm/stm32l0xx/include/mcu/stm32l0_bsp.h,C,apache-2.0,1735 1,"package com.hazelcast.simulator.worker.metronome; import java.util.concurrent.TimeUnit; public class BusySpinningMetronomeTest extends AbstractMetronomeTest { @Override public Metronome createMetronome(long interval, TimeUnit unit) { return new BusySpinningMetronome(unit.toNanos(interval),true); } } ",jerrinot/hazelcast-stabilizer,simulator/src/test/java/com/hazelcast/simulator/worker/metronome/BusySpinningMetronomeTest.java,Java,apache-2.0,325 2,"#!/usr/bin/env python from tests.unit import unittest from tests.unit import AWSMockServiceTestCase import mock from boto.ec2.connection import EC2Connection DESCRIBE_INSTANCE_VPC = r"""""" c6132c74-b524-4884-87f5-0f4bde4a9760 r-72ef4a0a 184906166255 i-instance ami-1624987f 16 running mykeypair 0 m1.small 2012-12-14T23:48:37.000Z us-east-1d default aki-88aa75e1 disabled subnet-0dc60667 vpc-id 10.0.0.67 true sg-id WebServerSG x86_64 ebs /dev/sda1 /dev/sda1 vol-id attached 2012-12-14T23:48:43.000Z true paravirtual foo Name xen eni-id subnet-id vpc-id Primary network interface ownerid in-use 10.0.0.67 true sg-id WebServerSG eni-attach-id 0 attached 2012-12-14T23:48:37.000Z true 10.0.0.67 true 10.0.0.54 false 10.0.0.55 false false """""" RUN_INSTANCE_RESPONSE = r"""""" ad4b83c2-f606-4c39-90c6-5dcc5be823e1 r-c5cef7a7 ownerid sg-id SSH i-ff0f1299 ami-ed65ba84 0 pending awskeypair 0 t1.micro 2012-05-30T19:21:18.000Z us-east-1a default aki-b6aa75df disabled sg-99a710f1 SSH pending pending i386 ebs /dev/sda1 paravirtual xen arn:aws:iam::ownerid:instance-profile/myinstanceprofile iamid """""" class TestRunInstanceResponseParsing(unittest.TestCase): def testIAMInstanceProfileParsedCorrectly(self): ec2 = EC2Connection(aws_access_key_id='aws_access_key_id', aws_secret_access_key='aws_secret_access_key') mock_response = mock.Mock() mock_response.read.return_value = RUN_INSTANCE_RESPONSE mock_response.status = 200 ec2.make_request = mock.Mock(return_value=mock_response) reservation = ec2.run_instances(image_id='ami-12345') self.assertEqual(len(reservation.instances), 1) instance = reservation.instances[0] self.assertEqual(instance.image_id, 'ami-ed65ba84') # iamInstanceProfile has an ID element, so we want to make sure # that this does not map to instance.id (which should be the # id of the ec2 instance). self.assertEqual(instance.id, 'i-ff0f1299') self.assertDictEqual( instance.instance_profile, {'arn': ('arn:aws:iam::ownerid:' 'instance-profile/myinstanceprofile'), 'id': 'iamid'}) class TestDescribeInstances(AWSMockServiceTestCase): connection_class = EC2Connection def default_body(self): return DESCRIBE_INSTANCE_VPC def test_multiple_private_ip_addresses(self): self.set_http_response(status_code=200) api_response = self.service_connection.get_all_reservations() self.assertEqual(len(api_response), 1) instances = api_response[0].instances self.assertEqual(len(instances), 1) instance = instances[0] self.assertEqual(len(instance.interfaces), 1) interface = instance.interfaces[0] self.assertEqual(len(interface.private_ip_addresses), 3) addresses = interface.private_ip_addresses self.assertEqual(addresses[0].private_ip_address, '10.0.0.67') self.assertTrue(addresses[0].primary) self.assertEqual(addresses[1].private_ip_address, '10.0.0.54') self.assertFalse(addresses[1].primary) self.assertEqual(addresses[2].private_ip_address, '10.0.0.55') self.assertFalse(addresses[2].primary) if __name__ == '__main__': unittest.main() ",harshilasu/GraphicMelon,y/google-cloud-sdk/platform/gsutil/third_party/boto/tests/unit/ec2/test_instance.py,Python,gpl-3.0,9932 3,"/* * Copyright (c) 2000, 2014, 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 sun.awt.datatransfer; import java.awt.EventQueue; import java.awt.Graphics; import java.awt.Image; import java.awt.Toolkit; import java.awt.datatransfer.DataFlavor; import java.awt.datatransfer.FlavorMap; import java.awt.datatransfer.FlavorTable; import java.awt.datatransfer.Transferable; import java.awt.datatransfer.UnsupportedFlavorException; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.InputStream; import java.io.InputStreamReader; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Reader; import java.io.SequenceInputStream; import java.io.StringReader; import java.net.URI; import java.net.URISyntaxException; import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.charset.Charset; import java.nio.charset.CharsetEncoder; import java.nio.charset.IllegalCharsetNameException; import java.nio.charset.UnsupportedCharsetException; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.security.AccessController; import java.security.PrivilegedAction; import java.security.PrivilegedActionException; import java.security.PrivilegedExceptionAction; import java.security.ProtectionDomain; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.SortedMap; import java.util.SortedSet; import java.util.Set; import java.util.Stack; import java.util.TreeMap; import java.util.TreeSet; import sun.awt.ComponentFactory; import sun.util.logging.PlatformLogger; import sun.awt.AppContext; import sun.awt.SunToolkit; import java.awt.image.BufferedImage; import java.awt.image.ImageObserver; import java.awt.image.RenderedImage; import java.awt.image.WritableRaster; import java.awt.image.ColorModel; import javax.imageio.ImageIO; import javax.imageio.ImageReader; import javax.imageio.ImageReadParam; import javax.imageio.ImageWriter; import javax.imageio.ImageTypeSpecifier; import javax.imageio.spi.ImageWriterSpi; import javax.imageio.stream.ImageInputStream; import javax.imageio.stream.ImageOutputStream; import sun.awt.image.ImageRepresentation; import sun.awt.image.ToolkitImage; import java.io.FilePermission; /** * Provides a set of functions to be shared among the DataFlavor class and * platform-specific data transfer implementations. * * The concept of ""flavors"" and ""natives"" is extended to include ""formats"", * which are the numeric values Win32 and X11 use to express particular data * types. Like FlavorMap, which provides getNativesForFlavors(DataFlavor[]) and * getFlavorsForNatives(String[]) functions, DataTransferer provides a set * of getFormatsFor(Transferable|Flavor|Flavors) and * getFlavorsFor(Format|Formats) functions. * * Also provided are functions for translating a Transferable into a byte * array, given a source DataFlavor and a target format, and for translating * a byte array or InputStream into an Object, given a source format and * a target DataFlavor. * * @author David Mendenhall * @author Danila Sinopalnikov * * @since 1.3.1 */ public abstract class DataTransferer { /** * The DataFlavor representing plain text with Unicode * encoding, where: *
     *     representationClass = java.lang.String
     *     mimeType            = ""text/plain; charset=Unicode""
     * 
*/ public static final DataFlavor plainTextStringFlavor; /** * The DataFlavor representing a Java text encoding String * encoded in UTF-8, where *
     *     representationClass = [B
     *     mimeType            = ""application/x-java-text-encoding""
     * 
*/ public static final DataFlavor javaTextEncodingFlavor; /** * Lazy initialization of Standard Encodings. */ private static class StandardEncodingsHolder { private static final SortedSet standardEncodings = load(); private static SortedSet load() { final Comparator comparator = new CharsetComparator(IndexedComparator.SELECT_WORST); final SortedSet tempSet = new TreeSet(comparator); tempSet.add(""US-ASCII""); tempSet.add(""ISO-8859-1""); tempSet.add(""UTF-8""); tempSet.add(""UTF-16BE""); tempSet.add(""UTF-16LE""); tempSet.add(""UTF-16""); tempSet.add(getDefaultTextCharset()); return Collections.unmodifiableSortedSet(tempSet); } } /** * Tracks whether a particular text/* MIME type supports the charset * parameter. The Map is initialized with all of the standard MIME types * listed in the DataFlavor.selectBestTextFlavor method comment. Additional * entries may be added during the life of the JRE for text/ types. */ private static final Map textMIMESubtypeCharsetSupport; /** * Cache of the platform default encoding as specified in the * ""file.encoding"" system property. */ private static String defaultEncoding; /** * A collection of all natives listed in flavormap.properties with * a primary MIME type of ""text"". */ private static final Set textNatives = Collections.synchronizedSet(new HashSet()); /** * The native encodings/charsets for the Set of textNatives. */ private static final Map nativeCharsets = Collections.synchronizedMap(new HashMap()); /** * The end-of-line markers for the Set of textNatives. */ private static final Map nativeEOLNs = Collections.synchronizedMap(new HashMap()); /** * The number of terminating NUL bytes for the Set of textNatives. */ private static final Map nativeTerminators = Collections.synchronizedMap(new HashMap()); /** * The key used to store pending data conversion requests for an AppContext. */ private static final String DATA_CONVERTER_KEY = ""DATA_CONVERTER_KEY""; /** * The singleton DataTransferer instance. It is created during MToolkit * or WToolkit initialization. */ private static DataTransferer transferer; private static final PlatformLogger dtLog = PlatformLogger.getLogger(""sun.awt.datatransfer.DataTransfer""); static { DataFlavor tPlainTextStringFlavor = null; try { tPlainTextStringFlavor = new DataFlavor (""text/plain;charset=Unicode;class=java.lang.String""); } catch (ClassNotFoundException cannotHappen) { } plainTextStringFlavor = tPlainTextStringFlavor; DataFlavor tJavaTextEncodingFlavor = null; try { tJavaTextEncodingFlavor = new DataFlavor (""application/x-java-text-encoding;class=\""[B\""""); } catch (ClassNotFoundException cannotHappen) { } javaTextEncodingFlavor = tJavaTextEncodingFlavor; Map tempMap = new HashMap(17); tempMap.put(""sgml"", Boolean.TRUE); tempMap.put(""xml"", Boolean.TRUE); tempMap.put(""html"", Boolean.TRUE); tempMap.put(""enriched"", Boolean.TRUE); tempMap.put(""richtext"", Boolean.TRUE); tempMap.put(""uri-list"", Boolean.TRUE); tempMap.put(""directory"", Boolean.TRUE); tempMap.put(""css"", Boolean.TRUE); tempMap.put(""calendar"", Boolean.TRUE); tempMap.put(""plain"", Boolean.TRUE); tempMap.put(""rtf"", Boolean.FALSE); tempMap.put(""tab-separated-values"", Boolean.FALSE); tempMap.put(""t140"", Boolean.FALSE); tempMap.put(""rfc822-headers"", Boolean.FALSE); tempMap.put(""parityfec"", Boolean.FALSE); textMIMESubtypeCharsetSupport = Collections.synchronizedMap(tempMap); } /** * The accessor method for the singleton DataTransferer instance. Note * that in a headless environment, there may be no DataTransferer instance; * instead, null will be returned. */ public static synchronized DataTransferer getInstance() { return ((ComponentFactory) Toolkit.getDefaultToolkit()).getDataTransferer(); } /** * Converts an arbitrary text encoding to its canonical name. */ public static String canonicalName(String encoding) { if (encoding == null) { return null; } try { return Charset.forName(encoding).name(); } catch (IllegalCharsetNameException icne) { return encoding; } catch (UnsupportedCharsetException uce) { return encoding; } } /** * If the specified flavor is a text flavor which supports the ""charset"" * parameter, then this method returns that parameter, or the default * charset if no such parameter was specified at construction. For non- * text DataFlavors, and for non-charset text flavors, this method returns * null. */ public static String getTextCharset(DataFlavor flavor) { if (!isFlavorCharsetTextType(flavor)) { return null; } String encoding = flavor.getParameter(""charset""); return (encoding != null) ? encoding : getDefaultTextCharset(); } /** * Returns the platform's default character encoding. */ public static String getDefaultTextCharset() { if (defaultEncoding != null) { return defaultEncoding; } return defaultEncoding = Charset.defaultCharset().name(); } /** * Tests only whether the flavor's MIME type supports the charset * parameter. Must only be called for flavors with a primary type of * ""text"". */ public static boolean doesSubtypeSupportCharset(DataFlavor flavor) { if (dtLog.isLoggable(PlatformLogger.Level.FINE)) { if (!""text"".equals(flavor.getPrimaryType())) { dtLog.fine(""Assertion (\""text\"".equals(flavor.getPrimaryType())) failed""); } } String subType = flavor.getSubType(); if (subType == null) { return false; } Object support = textMIMESubtypeCharsetSupport.get(subType); if (support != null) { return (support == Boolean.TRUE); } boolean ret_val = (flavor.getParameter(""charset"") != null); textMIMESubtypeCharsetSupport.put (subType, (ret_val) ? Boolean.TRUE : Boolean.FALSE); return ret_val; } public static boolean doesSubtypeSupportCharset(String subType, String charset) { Object support = textMIMESubtypeCharsetSupport.get(subType); if (support != null) { return (support == Boolean.TRUE); } boolean ret_val = (charset != null); textMIMESubtypeCharsetSupport.put (subType, (ret_val) ? Boolean.TRUE : Boolean.FALSE); return ret_val; } /** * Returns whether this flavor is a text type which supports the * 'charset' parameter. */ public static boolean isFlavorCharsetTextType(DataFlavor flavor) { // Although stringFlavor doesn't actually support the charset // parameter (because its primary MIME type is not ""text""), it should // be treated as though it does. stringFlavor is semantically // equivalent to ""text/plain"" data. if (DataFlavor.stringFlavor.equals(flavor)) { return true; } if (!""text"".equals(flavor.getPrimaryType()) || !doesSubtypeSupportCharset(flavor)) { return false; } Class rep_class = flavor.getRepresentationClass(); if (flavor.isRepresentationClassReader() || String.class.equals(rep_class) || flavor.isRepresentationClassCharBuffer() || char[].class.equals(rep_class)) { return true; } if (!(flavor.isRepresentationClassInputStream() || flavor.isRepresentationClassByteBuffer() || byte[].class.equals(rep_class))) { return false; } String charset = flavor.getParameter(""charset""); return (charset != null) ? DataTransferer.isEncodingSupported(charset) : true; // null equals default encoding which is always supported } /** * Returns whether this flavor is a text type which does not support the * 'charset' parameter. */ public static boolean isFlavorNoncharsetTextType(DataFlavor flavor) { if (!""text"".equals(flavor.getPrimaryType()) || doesSubtypeSupportCharset(flavor)) { return false; } return (flavor.isRepresentationClassInputStream() || flavor.isRepresentationClassByteBuffer() || byte[].class.equals(flavor.getRepresentationClass())); } /** * Determines whether this JRE can both encode and decode text in the * specified encoding. */ public static boolean isEncodingSupported(String encoding) { if (encoding == null) { return false; } try { return Charset.isSupported(encoding); } catch (IllegalCharsetNameException icne) { return false; } } /** * Returns {@code true} if the given type is a java.rmi.Remote. */ public static boolean isRemote(Class type) { return RMI.isRemote(type); } /** * Returns an Iterator which traverses a SortedSet of Strings which are * a total order of the standard character sets supported by the JRE. The * ordering follows the same principles as DataFlavor.selectBestTextFlavor. * So as to avoid loading all available character converters, optional, * non-standard, character sets are not included. */ public static Set standardEncodings() { return StandardEncodingsHolder.standardEncodings; } /** * Converts a FlavorMap to a FlavorTable. */ public static FlavorTable adaptFlavorMap(final FlavorMap map) { if (map instanceof FlavorTable) { return (FlavorTable)map; } return new FlavorTable() { public Map getNativesForFlavors(DataFlavor[] flavors) { return map.getNativesForFlavors(flavors); } public Map getFlavorsForNatives(String[] natives) { return map.getFlavorsForNatives(natives); } public List getNativesForFlavor(DataFlavor flav) { Map natives = getNativesForFlavors(new DataFlavor[] { flav } ); String nat = (String)natives.get(flav); if (nat != null) { List list = new ArrayList(1); list.add(nat); return list; } else { return Collections.EMPTY_LIST; } } public List getFlavorsForNative(String nat) { Map flavors = getFlavorsForNatives(new String[] { nat } ); DataFlavor flavor = (DataFlavor)flavors.get(nat); if (flavor != null) { List list = new ArrayList(1); list.add(flavor); return list; } else { return Collections.EMPTY_LIST; } } }; } /** * Returns the default Unicode encoding for the platform. The encoding * need not be canonical. This method is only used by the archaic function * DataFlavor.getTextPlainUnicodeFlavor(). */ public abstract String getDefaultUnicodeEncoding(); /** * This method is called for text flavor mappings established while parsing * the flavormap.properties file. It stores the ""eoln"" and ""terminators"" * parameters which are not officially part of the MIME type. They are * MIME parameters specific to the flavormap.properties file format. */ public void registerTextFlavorProperties(String nat, String charset, String eoln, String terminators) { Long format = getFormatForNativeAsLong(nat); textNatives.add(format); nativeCharsets.put(format, (charset != null && charset.length() != 0) ? charset : getDefaultTextCharset()); if (eoln != null && eoln.length() != 0 && !eoln.equals(""\n"")) { nativeEOLNs.put(format, eoln); } if (terminators != null && terminators.length() != 0) { Integer iTerminators = Integer.valueOf(terminators); if (iTerminators.intValue() > 0) { nativeTerminators.put(format, iTerminators); } } } /** * Determines whether the native corresponding to the specified long format * was listed in the flavormap.properties file. */ protected boolean isTextFormat(long format) { return textNatives.contains(Long.valueOf(format)); } protected String getCharsetForTextFormat(Long lFormat) { return (String)nativeCharsets.get(lFormat); } /** * Specifies whether text imported from the native system in the specified * format is locale-dependent. If so, when decoding such text, * 'nativeCharsets' should be ignored, and instead, the Transferable should * be queried for its javaTextEncodingFlavor data for the correct encoding. */ public abstract boolean isLocaleDependentTextFormat(long format); /** * Determines whether the DataFlavor corresponding to the specified long * format is DataFlavor.javaFileListFlavor. */ public abstract boolean isFileFormat(long format); /** * Determines whether the DataFlavor corresponding to the specified long * format is DataFlavor.imageFlavor. */ public abstract boolean isImageFormat(long format); /** * Determines whether the format is a URI list we can convert to * a DataFlavor.javaFileListFlavor. */ protected boolean isURIListFormat(long format) { return false; } /** * Returns a Map whose keys are all of the possible formats into which the * Transferable's transfer data flavors can be translated. The value of * each key is the DataFlavor in which the Transferable's data should be * requested when converting to the format. *

* The map keys are sorted according to the native formats preference * order. */ public SortedMap getFormatsForTransferable( Transferable contents, FlavorTable map) { DataFlavor[] flavors = contents.getTransferDataFlavors(); if (flavors == null) { return new TreeMap(); } return getFormatsForFlavors(flavors, map); } /** * Returns a Map whose keys are all of the possible formats into which data * in the specified DataFlavor can be translated. The value of each key * is the DataFlavor in which a Transferable's data should be requested * when converting to the format. *

* The map keys are sorted according to the native formats preference * order. */ public SortedMap getFormatsForFlavor(DataFlavor flavor, FlavorTable map) { return getFormatsForFlavors(new DataFlavor[] { flavor }, map); } /** * Returns a Map whose keys are all of the possible formats into which data * in the specified DataFlavors can be translated. The value of each key * is the DataFlavor in which the Transferable's data should be requested * when converting to the format. *

* The map keys are sorted according to the native formats preference * order. * * @param flavors the data flavors * @param map the FlavorTable which contains mappings between * DataFlavors and data formats * @throws NullPointerException if flavors or map is null */ public SortedMap getFormatsForFlavors( DataFlavor[] flavors, FlavorTable map) { Map formatMap = new HashMap <> (flavors.length); Map textPlainMap = new HashMap <> (flavors.length); // Maps formats to indices that will be used to sort the formats // according to the preference order. // Larger index value corresponds to the more preferable format. Map indexMap = new HashMap(flavors.length); Map textPlainIndexMap = new HashMap(flavors.length); int currentIndex = 0; // Iterate backwards so that preferred DataFlavors are used over // other DataFlavors. (See javadoc for // Transferable.getTransferDataFlavors.) for (int i = flavors.length - 1; i >= 0; i--) { DataFlavor flavor = flavors[i]; if (flavor == null) continue; // Don't explicitly test for String, since it is just a special // case of Serializable if (flavor.isFlavorTextType() || flavor.isFlavorJavaFileListType() || DataFlavor.imageFlavor.equals(flavor) || flavor.isRepresentationClassSerializable() || flavor.isRepresentationClassInputStream() || flavor.isRepresentationClassRemote()) { List natives = map.getNativesForFlavor(flavor); currentIndex += natives.size(); for (Iterator iter = natives.iterator(); iter.hasNext(); ) { Long lFormat = getFormatForNativeAsLong((String)iter.next()); Integer index = Integer.valueOf(currentIndex--); formatMap.put(lFormat, flavor); indexMap.put(lFormat, index); // SystemFlavorMap.getNativesForFlavor will return // text/plain natives for all text/*. While this is good // for a single text/* flavor, we would prefer that // text/plain native data come from a text/plain flavor. if ((""text"".equals(flavor.getPrimaryType()) && ""plain"".equals(flavor.getSubType())) || flavor.equals(DataFlavor.stringFlavor)) { textPlainMap.put(lFormat, flavor); textPlainIndexMap.put(lFormat, index); } } currentIndex += natives.size(); } } formatMap.putAll(textPlainMap); indexMap.putAll(textPlainIndexMap); // Sort the map keys according to the formats preference order. Comparator comparator = new IndexOrderComparator(indexMap, IndexedComparator.SELECT_WORST); SortedMap sortedMap = new TreeMap(comparator); sortedMap.putAll(formatMap); return sortedMap; } /** * Reduces the Map output for the root function to an array of the * Map's keys. */ public long[] getFormatsForTransferableAsArray(Transferable contents, FlavorTable map) { return keysToLongArray(getFormatsForTransferable(contents, map)); } public long[] getFormatsForFlavorAsArray(DataFlavor flavor, FlavorTable map) { return keysToLongArray(getFormatsForFlavor(flavor, map)); } public long[] getFormatsForFlavorsAsArray(DataFlavor[] flavors, FlavorTable map) { return keysToLongArray(getFormatsForFlavors(flavors, map)); } /** * Returns a Map whose keys are all of the possible DataFlavors into which * data in the specified format can be translated. The value of each key * is the format in which the Clipboard or dropped data should be requested * when converting to the DataFlavor. */ public Map getFlavorsForFormat(long format, FlavorTable map) { return getFlavorsForFormats(new long[] { format }, map); } /** * Returns a Map whose keys are all of the possible DataFlavors into which * data in the specified formats can be translated. The value of each key * is the format in which the Clipboard or dropped data should be requested * when converting to the DataFlavor. */ public Map getFlavorsForFormats(long[] formats, FlavorTable map) { Map flavorMap = new HashMap(formats.length); Set mappingSet = new HashSet(formats.length); Set flavorSet = new HashSet(formats.length); // First step: build flavorSet, mappingSet and initial flavorMap // flavorSet - the set of all the DataFlavors into which // data in the specified formats can be translated; // mappingSet - the set of all the mappings from the specified formats // into any DataFlavor; // flavorMap - after this step, this map maps each of the DataFlavors // from flavorSet to any of the specified formats. for (int i = 0; i < formats.length; i++) { long format = formats[i]; String nat = getNativeForFormat(format); List flavors = map.getFlavorsForNative(nat); for (Iterator iter = flavors.iterator(); iter.hasNext(); ) { DataFlavor flavor = (DataFlavor)iter.next(); // Don't explicitly test for String, since it is just a special // case of Serializable if (flavor.isFlavorTextType() || flavor.isFlavorJavaFileListType() || DataFlavor.imageFlavor.equals(flavor) || flavor.isRepresentationClassSerializable() || flavor.isRepresentationClassInputStream() || flavor.isRepresentationClassRemote()) { Long lFormat = Long.valueOf(format); Object mapping = DataTransferer.createMapping(lFormat, flavor); flavorMap.put(flavor, lFormat); mappingSet.add(mapping); flavorSet.add(flavor); } } } // Second step: for each DataFlavor try to figure out which of the // specified formats is the best to translate to this flavor. // Then map each flavor to the best format. // For the given flavor, FlavorTable indicates which native will // best reflect data in the specified flavor to the underlying native // platform. We assume that this native is the best to translate // to this flavor. // Note: FlavorTable allows one-way mappings, so we can occasionally // map a flavor to the format for which the corresponding // format-to-flavor mapping doesn't exist. For this reason we have built // a mappingSet of all format-to-flavor mappings for the specified formats // and check if the format-to-flavor mapping exists for the // (flavor,format) pair being added. for (Iterator flavorIter = flavorSet.iterator(); flavorIter.hasNext(); ) { DataFlavor flavor = (DataFlavor)flavorIter.next(); List natives = map.getNativesForFlavor(flavor); for (Iterator nativeIter = natives.iterator(); nativeIter.hasNext(); ) { Long lFormat = getFormatForNativeAsLong((String)nativeIter.next()); Object mapping = DataTransferer.createMapping(lFormat, flavor); if (mappingSet.contains(mapping)) { flavorMap.put(flavor, lFormat); break; } } } return flavorMap; } /** * Returns a Set of all DataFlavors for which * 1) a mapping from at least one of the specified formats exists in the * specified map and * 2) the data translation for this mapping can be performed by the data * transfer subsystem. * * @param formats the data formats * @param map the FlavorTable which contains mappings between * DataFlavors and data formats * @throws NullPointerException if formats or map is null */ public Set getFlavorsForFormatsAsSet(long[] formats, FlavorTable map) { Set flavorSet = new HashSet(formats.length); for (int i = 0; i < formats.length; i++) { String nat = getNativeForFormat(formats[i]); List flavors = map.getFlavorsForNative(nat); for (Iterator iter = flavors.iterator(); iter.hasNext(); ) { DataFlavor flavor = (DataFlavor)iter.next(); // Don't explicitly test for String, since it is just a special // case of Serializable if (flavor.isFlavorTextType() || flavor.isFlavorJavaFileListType() || DataFlavor.imageFlavor.equals(flavor) || flavor.isRepresentationClassSerializable() || flavor.isRepresentationClassInputStream() || flavor.isRepresentationClassRemote()) { flavorSet.add(flavor); } } } return flavorSet; } /** * Returns an array of all DataFlavors for which * 1) a mapping from the specified format exists in the specified map and * 2) the data translation for this mapping can be performed by the data * transfer subsystem. * The array will be sorted according to a * DataFlavorComparator created with the specified * map as an argument. * * @param format the data format * @param map the FlavorTable which contains mappings between * DataFlavors and data formats * @throws NullPointerException if map is null */ public DataFlavor[] getFlavorsForFormatAsArray(long format, FlavorTable map) { return getFlavorsForFormatsAsArray(new long[] { format }, map); } /** * Returns an array of all DataFlavors for which * 1) a mapping from at least one of the specified formats exists in the * specified map and * 2) the data translation for this mapping can be performed by the data * transfer subsystem. * The array will be sorted according to a * DataFlavorComparator created with the specified * map as an argument. * * @param formats the data formats * @param map the FlavorTable which contains mappings between * DataFlavors and data formats * @throws NullPointerException if formats or map is null */ public DataFlavor[] getFlavorsForFormatsAsArray(long[] formats, FlavorTable map) { // getFlavorsForFormatsAsSet() is less expensive than // getFlavorsForFormats(). return setToSortedDataFlavorArray(getFlavorsForFormatsAsSet(formats, map)); } /** * Returns an object that represents a mapping between the specified * key and value. null values and the null keys are * permitted. The internal representation of the mapping object is * irrelevant. The only requrement is that the two mapping objects are equal * if and only if their keys are equal and their values are equal. * More formally, the two mapping objects are equal if and only if * (value1 == null ? value2 == null : value1.equals(value2)) * && (key1 == null ? key2 == null : key1.equals(key2)). */ private static Object createMapping(Object key, Object value) { // NOTE: Should be updated to use AbstractMap.SimpleEntry as // soon as it is made public. return Arrays.asList(new Object[] { key, value }); } /** * Looks-up or registers the String native with the native data transfer * system and returns a long format corresponding to that native. */ protected abstract Long getFormatForNativeAsLong(String str); /** * Looks-up the String native corresponding to the specified long format in * the native data transfer system. */ protected abstract String getNativeForFormat(long format); /* Contains common code for finding the best charset for * clipboard string encoding/decoding, basing on clipboard * format and localeTransferable(on decoding, if available) */ private String getBestCharsetForTextFormat(Long lFormat, Transferable localeTransferable) throws IOException { String charset = null; if (localeTransferable != null && isLocaleDependentTextFormat(lFormat) && localeTransferable.isDataFlavorSupported(javaTextEncodingFlavor)) { try { charset = new String( (byte[])localeTransferable.getTransferData(javaTextEncodingFlavor), ""UTF-8"" ); } catch (UnsupportedFlavorException cannotHappen) { } } else { charset = getCharsetForTextFormat(lFormat); } if (charset == null) { // Only happens when we have a custom text type. charset = getDefaultTextCharset(); } return charset; } /** * Translation function for converting string into * a byte array. Search-and-replace EOLN. Encode into the * target format. Append terminating NUL bytes. * * Java to Native string conversion */ private byte[] translateTransferableString(String str, long format) throws IOException { Long lFormat = Long.valueOf(format); String charset = getBestCharsetForTextFormat(lFormat, null); // Search and replace EOLN. Note that if EOLN is ""\n"", then we // never added an entry to nativeEOLNs anyway, so we'll skip this // code altogether. // windows: ""abc\nde""->""abc\r\nde"" String eoln = (String)nativeEOLNs.get(lFormat); if (eoln != null) { int length = str.length(); StringBuffer buffer = new StringBuffer(length * 2); // 2 is a heuristic for (int i = 0; i < length; i++) { // Fix for 4914613 - skip native EOLN if (str.startsWith(eoln, i)) { buffer.append(eoln); i += eoln.length() - 1; continue; } char c = str.charAt(i); if (c == '\n') { buffer.append(eoln); } else { buffer.append(c); } } str = buffer.toString(); } // Encode text in target format. byte[] bytes = str.getBytes(charset); // Append terminating NUL bytes. Note that if terminators is 0, // the we never added an entry to nativeTerminators anyway, so // we'll skip code altogether. // ""abcde"" -> ""abcde\0"" Integer terminators = (Integer)nativeTerminators.get(lFormat); if (terminators != null) { int numTerminators = terminators.intValue(); byte[] terminatedBytes = new byte[bytes.length + numTerminators]; System.arraycopy(bytes, 0, terminatedBytes, 0, bytes.length); for (int i = bytes.length; i < terminatedBytes.length; i++) { terminatedBytes[i] = 0x0; } bytes = terminatedBytes; } return bytes; } /** * Translating either a byte array or an InputStream into an String. * Strip terminators and search-and-replace EOLN. * * Native to Java string conversion */ private String translateBytesToString(byte[] bytes, long format, Transferable localeTransferable) throws IOException { Long lFormat = Long.valueOf(format); String charset = getBestCharsetForTextFormat(lFormat, localeTransferable); // Locate terminating NUL bytes. Note that if terminators is 0, // the we never added an entry to nativeTerminators anyway, so // we'll skip code altogether. // In other words: we are doing char alignment here basing on suggestion // that count of zero-'terminators' is a number of bytes in one symbol // for selected charset (clipboard format). It is not complitly true for // multibyte coding like UTF-8, but helps understand the procedure. // ""abcde\0"" -> ""abcde"" String eoln = (String)nativeEOLNs.get(lFormat); Integer terminators = (Integer)nativeTerminators.get(lFormat); int count; if (terminators != null) { int numTerminators = terminators.intValue(); search: for (count = 0; count < (bytes.length - numTerminators + 1); count += numTerminators) { for (int i = count; i < count + numTerminators; i++) { if (bytes[i] != 0x0) { continue search; } } // found terminators break search; } } else { count = bytes.length; } // Decode text to chars. Don't include any terminators. String converted = new String(bytes, 0, count, charset); // Search and replace EOLN. Note that if EOLN is ""\n"", then we // never added an entry to nativeEOLNs anyway, so we'll skip this // code altogether. // Count of NUL-terminators and EOLN coding are platform-specific and // loaded from flavormap.properties file // windows: ""abc\r\nde"" -> ""abc\nde"" if (eoln != null) { /* Fix for 4463560: replace EOLNs symbol-by-symbol instead * of using buf.replace() */ char[] buf = converted.toCharArray(); char[] eoln_arr = eoln.toCharArray(); converted = null; int j = 0; boolean match; for (int i = 0; i < buf.length; ) { // Catch last few bytes if (i + eoln_arr.length > buf.length) { buf[j++] = buf[i++]; continue; } match = true; for (int k = 0, l = i; k < eoln_arr.length; k++, l++) { if (eoln_arr[k] != buf[l]) { match = false; break; } } if (match) { buf[j++] = '\n'; i += eoln_arr.length; } else { buf[j++] = buf[i++]; } } converted = new String(buf, 0, j); } return converted; } /** * Primary translation function for translating a Transferable into * a byte array, given a source DataFlavor and target format. */ public byte[] translateTransferable(Transferable contents, DataFlavor flavor, long format) throws IOException { // Obtain the transfer data in the source DataFlavor. // // Note that we special case DataFlavor.plainTextFlavor because // StringSelection supports this flavor incorrectly -- instead of // returning an InputStream as the DataFlavor representation class // states, it returns a Reader. Instead of using this broken // functionality, we request the data in stringFlavor (the other // DataFlavor which StringSelection supports) and use the String // translator. Object obj; boolean stringSelectionHack; try { obj = contents.getTransferData(flavor); if (obj == null) { return null; } if (flavor.equals(DataFlavor.plainTextFlavor) && !(obj instanceof InputStream)) { obj = contents.getTransferData(DataFlavor.stringFlavor); if (obj == null) { return null; } stringSelectionHack = true; } else { stringSelectionHack = false; } } catch (UnsupportedFlavorException e) { throw new IOException(e.getMessage()); } // Source data is a String. Search-and-replace EOLN. Encode into the // target format. Append terminating NUL bytes. if (stringSelectionHack || (String.class.equals(flavor.getRepresentationClass()) && isFlavorCharsetTextType(flavor) && isTextFormat(format))) { String str = removeSuspectedData(flavor, contents, (String)obj); return translateTransferableString( str, format); // Source data is a Reader. Convert to a String and recur. In the // future, we may want to rewrite this so that we encode on demand. } else if (flavor.isRepresentationClassReader()) { if (!(isFlavorCharsetTextType(flavor) && isTextFormat(format))) { throw new IOException (""cannot transfer non-text data as Reader""); } StringBuffer buf = new StringBuffer(); try (Reader r = (Reader)obj) { int c; while ((c = r.read()) != -1) { buf.append((char)c); } } return translateTransferableString( buf.toString(), format); // Source data is a CharBuffer. Convert to a String and recur. } else if (flavor.isRepresentationClassCharBuffer()) { if (!(isFlavorCharsetTextType(flavor) && isTextFormat(format))) { throw new IOException (""cannot transfer non-text data as CharBuffer""); } CharBuffer buffer = (CharBuffer)obj; int size = buffer.remaining(); char[] chars = new char[size]; buffer.get(chars, 0, size); return translateTransferableString( new String(chars), format); // Source data is a char array. Convert to a String and recur. } else if (char[].class.equals(flavor.getRepresentationClass())) { if (!(isFlavorCharsetTextType(flavor) && isTextFormat(format))) { throw new IOException (""cannot transfer non-text data as char array""); } return translateTransferableString( new String((char[])obj), format); // Source data is a ByteBuffer. For arbitrary flavors, simply return // the array. For text flavors, decode back to a String and recur to // reencode according to the requested format. } else if (flavor.isRepresentationClassByteBuffer()) { ByteBuffer buffer = (ByteBuffer)obj; int size = buffer.remaining(); byte[] bytes = new byte[size]; buffer.get(bytes, 0, size); if (isFlavorCharsetTextType(flavor) && isTextFormat(format)) { String sourceEncoding = DataTransferer.getTextCharset(flavor); return translateTransferableString( new String(bytes, sourceEncoding), format); } else { return bytes; } // Source data is a byte array. For arbitrary flavors, simply return // the array. For text flavors, decode back to a String and recur to // reencode according to the requested format. } else if (byte[].class.equals(flavor.getRepresentationClass())) { byte[] bytes = (byte[])obj; if (isFlavorCharsetTextType(flavor) && isTextFormat(format)) { String sourceEncoding = DataTransferer.getTextCharset(flavor); return translateTransferableString( new String(bytes, sourceEncoding), format); } else { return bytes; } // Source data is Image } else if (DataFlavor.imageFlavor.equals(flavor)) { if (!isImageFormat(format)) { throw new IOException(""Data translation failed: "" + ""not an image format""); } Image image = (Image)obj; byte[] bytes = imageToPlatformBytes(image, format); if (bytes == null) { throw new IOException(""Data translation failed: "" + ""cannot convert java image to native format""); } return bytes; } byte[] theByteArray = null; // Target data is a file list. Source data must be a // java.util.List which contains java.io.File or String instances. if (isFileFormat(format)) { if (!DataFlavor.javaFileListFlavor.equals(flavor)) { throw new IOException(""data translation failed""); } final List list = (List)obj; final ProtectionDomain userProtectionDomain = getUserProtectionDomain(contents); final ArrayList fileList = castToFiles(list, userProtectionDomain); try (ByteArrayOutputStream bos = convertFileListToBytes(fileList)) { theByteArray = bos.toByteArray(); } // Target data is a URI list. Source data must be a // java.util.List which contains java.io.File or String instances. } else if (isURIListFormat(format)) { if (!DataFlavor.javaFileListFlavor.equals(flavor)) { throw new IOException(""data translation failed""); } String nat = getNativeForFormat(format); String targetCharset = null; if (nat != null) { try { targetCharset = new DataFlavor(nat).getParameter(""charset""); } catch (ClassNotFoundException cnfe) { throw new IOException(cnfe); } } if (targetCharset == null) { targetCharset = ""UTF-8""; } final List list = (List)obj; final ProtectionDomain userProtectionDomain = getUserProtectionDomain(contents); final ArrayList fileList = castToFiles(list, userProtectionDomain); final ArrayList uriList = new ArrayList(fileList.size()); for (String fileObject : fileList) { final URI uri = new File(fileObject).toURI(); // Some implementations are fussy about the number of slashes (file:///path/to/file is best) try { uriList.add(new URI(uri.getScheme(), """", uri.getPath(), uri.getFragment()).toString()); } catch (URISyntaxException uriSyntaxException) { throw new IOException(uriSyntaxException); } } byte[] eoln = ""\r\n"".getBytes(targetCharset); try (ByteArrayOutputStream bos = new ByteArrayOutputStream()) { for (int i = 0; i < uriList.size(); i++) { byte[] bytes = uriList.get(i).getBytes(targetCharset); bos.write(bytes, 0, bytes.length); bos.write(eoln, 0, eoln.length); } theByteArray = bos.toByteArray(); } // Source data is an InputStream. For arbitrary flavors, just grab the // bytes and dump them into a byte array. For text flavors, decode back // to a String and recur to reencode according to the requested format. } else if (flavor.isRepresentationClassInputStream()) { try (ByteArrayOutputStream bos = new ByteArrayOutputStream()) { try (InputStream is = (InputStream)obj) { boolean eof = false; int avail = is.available(); byte[] tmp = new byte[avail > 8192 ? avail : 8192]; do { int aValue; if (!(eof = (aValue = is.read(tmp, 0, tmp.length)) == -1)) { bos.write(tmp, 0, aValue); } } while (!eof); } if (isFlavorCharsetTextType(flavor) && isTextFormat(format)) { byte[] bytes = bos.toByteArray(); String sourceEncoding = DataTransferer.getTextCharset(flavor); return translateTransferableString( new String(bytes, sourceEncoding), format); } theByteArray = bos.toByteArray(); } // Source data is an RMI object } else if (flavor.isRepresentationClassRemote()) { Object mo = RMI.newMarshalledObject(obj); theByteArray = convertObjectToBytes(mo); // Source data is Serializable } else if (flavor.isRepresentationClassSerializable()) { theByteArray = convertObjectToBytes(obj); } else { throw new IOException(""data translation failed""); } return theByteArray; } private static byte[] convertObjectToBytes(Object object) throws IOException { try (ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos)) { oos.writeObject(object); return bos.toByteArray(); } } protected abstract ByteArrayOutputStream convertFileListToBytes(ArrayList fileList) throws IOException; private String removeSuspectedData(DataFlavor flavor, final Transferable contents, final String str) throws IOException { if (null == System.getSecurityManager() || !flavor.isMimeTypeEqual(""text/uri-list"")) { return str; } String ret_val = """"; final ProtectionDomain userProtectionDomain = getUserProtectionDomain(contents); try { ret_val = (String) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() { StringBuffer allowedFiles = new StringBuffer(str.length()); String [] uriArray = str.split(""(\\s)+""); for (String fileName : uriArray) { File file = new File(fileName); if (file.exists() && !(isFileInWebstartedCache(file) || isForbiddenToRead(file, userProtectionDomain))) { if (0 != allowedFiles.length()) { allowedFiles.append(""\\r\\n""); } allowedFiles.append(fileName); } } return allowedFiles.toString(); } }); } catch (PrivilegedActionException pae) { throw new IOException(pae.getMessage(), pae); } return ret_val; } private static ProtectionDomain getUserProtectionDomain(Transferable contents) { return contents.getClass().getProtectionDomain(); } private boolean isForbiddenToRead (File file, ProtectionDomain protectionDomain) { if (null == protectionDomain) { return false; } try { FilePermission filePermission = new FilePermission(file.getCanonicalPath(), ""read, delete""); if (protectionDomain.implies(filePermission)) { return false; } } catch (IOException e) {} return true; } private ArrayList castToFiles(final List files, final ProtectionDomain userProtectionDomain) throws IOException { final ArrayList fileList = new ArrayList(); try { AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws IOException { for (Object fileObject : files) { File file = castToFile(fileObject); if (file != null && (null == System.getSecurityManager() || !(isFileInWebstartedCache(file) || isForbiddenToRead(file, userProtectionDomain)))) { fileList.add(file.getCanonicalPath()); } } return null; } }); } catch (PrivilegedActionException pae) { throw new IOException(pae.getMessage()); } return fileList; } // It is important do not use user's successors // of File class. private File castToFile(Object fileObject) throws IOException { String filePath = null; if (fileObject instanceof File) { filePath = ((File)fileObject).getCanonicalPath(); } else if (fileObject instanceof String) { filePath = (String) fileObject; } else { return null; } return new File(filePath); } private final static String[] DEPLOYMENT_CACHE_PROPERTIES = { ""deployment.system.cachedir"", ""deployment.user.cachedir"", ""deployment.javaws.cachedir"", ""deployment.javapi.cachedir"" }; private final static ArrayList deploymentCacheDirectoryList = new ArrayList(); private static boolean isFileInWebstartedCache(File f) { if (deploymentCacheDirectoryList.isEmpty()) { for (String cacheDirectoryProperty : DEPLOYMENT_CACHE_PROPERTIES) { String cacheDirectoryPath = System.getProperty(cacheDirectoryProperty); if (cacheDirectoryPath != null) { try { File cacheDirectory = (new File(cacheDirectoryPath)).getCanonicalFile(); if (cacheDirectory != null) { deploymentCacheDirectoryList.add(cacheDirectory); } } catch (IOException ioe) {} } } } for (File deploymentCacheDirectory : deploymentCacheDirectoryList) { for (File dir = f; dir != null; dir = dir.getParentFile()) { if (dir.equals(deploymentCacheDirectory)) { return true; } } } return false; } public Object translateBytes(byte[] bytes, DataFlavor flavor, long format, Transferable localeTransferable) throws IOException { Object theObject = null; // Source data is a file list. Use the dragQueryFile native function to // do most of the decoding. Then wrap File objects around the String // filenames and return a List. if (isFileFormat(format)) { if (!DataFlavor.javaFileListFlavor.equals(flavor)) { throw new IOException(""data translation failed""); } String[] filenames = dragQueryFile(bytes); if (filenames == null) { return null; } // Convert the strings to File objects File[] files = new File[filenames.length]; for (int i = 0; i < filenames.length; i++) { files[i] = new File(filenames[i]); } // Turn the list of Files into a List and return theObject = Arrays.asList(files); // Source data is a URI list. Convert to DataFlavor.javaFileListFlavor // where possible. } else if (isURIListFormat(format) && DataFlavor.javaFileListFlavor.equals(flavor)) { try (ByteArrayInputStream str = new ByteArrayInputStream(bytes)) { URI uris[] = dragQueryURIs(str, format, localeTransferable); if (uris == null) { return null; } List files = new ArrayList<>(); for (URI uri : uris) { try { files.add(new File(uri)); } catch (IllegalArgumentException illegalArg) { // When converting from URIs to less generic files, // common practice (Wine, SWT) seems to be to // silently drop the URIs that aren't local files. } } theObject = files; } // Target data is a String. Strip terminating NUL bytes. Decode bytes // into characters. Search-and-replace EOLN. } else if (String.class.equals(flavor.getRepresentationClass()) && isFlavorCharsetTextType(flavor) && isTextFormat(format)) { theObject = translateBytesToString(bytes, format, localeTransferable); // Target data is a Reader. Obtain data in InputStream format, encoded // as ""Unicode"" (utf-16be). Then use an InputStreamReader to decode // back to chars on demand. } else if (flavor.isRepresentationClassReader()) { try (ByteArrayInputStream bais = new ByteArrayInputStream(bytes)) { theObject = translateStream(bais, flavor, format, localeTransferable); } // Target data is a CharBuffer. Recur to obtain String and wrap. } else if (flavor.isRepresentationClassCharBuffer()) { if (!(isFlavorCharsetTextType(flavor) && isTextFormat(format))) { throw new IOException (""cannot transfer non-text data as CharBuffer""); } CharBuffer buffer = CharBuffer.wrap( translateBytesToString(bytes,format, localeTransferable)); theObject = constructFlavoredObject(buffer, flavor, CharBuffer.class); // Target data is a char array. Recur to obtain String and convert to // char array. } else if (char[].class.equals(flavor.getRepresentationClass())) { if (!(isFlavorCharsetTextType(flavor) && isTextFormat(format))) { throw new IOException (""cannot transfer non-text data as char array""); } theObject = translateBytesToString( bytes, format, localeTransferable).toCharArray(); // Target data is a ByteBuffer. For arbitrary flavors, just return // the raw bytes. For text flavors, convert to a String to strip // terminators and search-and-replace EOLN, then reencode according to // the requested flavor. } else if (flavor.isRepresentationClassByteBuffer()) { if (isFlavorCharsetTextType(flavor) && isTextFormat(format)) { bytes = translateBytesToString( bytes, format, localeTransferable).getBytes( DataTransferer.getTextCharset(flavor) ); } ByteBuffer buffer = ByteBuffer.wrap(bytes); theObject = constructFlavoredObject(buffer, flavor, ByteBuffer.class); // Target data is a byte array. For arbitrary flavors, just return // the raw bytes. For text flavors, convert to a String to strip // terminators and search-and-replace EOLN, then reencode according to // the requested flavor. } else if (byte[].class.equals(flavor.getRepresentationClass())) { if (isFlavorCharsetTextType(flavor) && isTextFormat(format)) { theObject = translateBytesToString( bytes, format, localeTransferable ).getBytes(DataTransferer.getTextCharset(flavor)); } else { theObject = bytes; } // Target data is an InputStream. For arbitrary flavors, just return // the raw bytes. For text flavors, decode to strip terminators and // search-and-replace EOLN, then reencode according to the requested // flavor. } else if (flavor.isRepresentationClassInputStream()) { try (ByteArrayInputStream bais = new ByteArrayInputStream(bytes)) { theObject = translateStream(bais, flavor, format, localeTransferable); } } else if (flavor.isRepresentationClassRemote()) { try (ByteArrayInputStream bais = new ByteArrayInputStream(bytes); ObjectInputStream ois = new ObjectInputStream(bais)) { theObject = RMI.getMarshalledObject(ois.readObject()); } catch (Exception e) { throw new IOException(e.getMessage()); } // Target data is Serializable } else if (flavor.isRepresentationClassSerializable()) { try (ByteArrayInputStream bais = new ByteArrayInputStream(bytes)) { theObject = translateStream(bais, flavor, format, localeTransferable); } // Target data is Image } else if (DataFlavor.imageFlavor.equals(flavor)) { if (!isImageFormat(format)) { throw new IOException(""data translation failed""); } theObject = platformImageBytesToImage(bytes, format); } if (theObject == null) { throw new IOException(""data translation failed""); } return theObject; } /** * Primary translation function for translating * an InputStream into an Object, given a source format and a target * DataFlavor. */ public Object translateStream(InputStream str, DataFlavor flavor, long format, Transferable localeTransferable) throws IOException { Object theObject = null; // Source data is a URI list. Convert to DataFlavor.javaFileListFlavor // where possible. if (isURIListFormat(format) && DataFlavor.javaFileListFlavor.equals(flavor)) { URI uris[] = dragQueryURIs(str, format, localeTransferable); if (uris == null) { return null; } ArrayList files = new ArrayList(); for (URI uri : uris) { try { files.add(new File(uri)); } catch (IllegalArgumentException illegalArg) { // When converting from URIs to less generic files, // common practice (Wine, SWT) seems to be to // silently drop the URIs that aren't local files. } } theObject = files; // Target data is a String. Strip terminating NUL bytes. Decode bytes // into characters. Search-and-replace EOLN. } else if (String.class.equals(flavor.getRepresentationClass()) && isFlavorCharsetTextType(flavor) && isTextFormat(format)) { return translateBytesToString(inputStreamToByteArray(str), format, localeTransferable); // Special hack to maintain backwards-compatibility with the brokenness // of StringSelection. Return a StringReader instead of an InputStream. // Recur to obtain String and encapsulate. } else if (DataFlavor.plainTextFlavor.equals(flavor)) { theObject = new StringReader(translateBytesToString( inputStreamToByteArray(str), format, localeTransferable)); // Target data is an InputStream. For arbitrary flavors, just return // the raw bytes. For text flavors, decode to strip terminators and // search-and-replace EOLN, then reencode according to the requested // flavor. } else if (flavor.isRepresentationClassInputStream()) { theObject = translateStreamToInputStream(str, flavor, format, localeTransferable); // Target data is a Reader. Obtain data in InputStream format, encoded // as ""Unicode"" (utf-16be). Then use an InputStreamReader to decode // back to chars on demand. } else if (flavor.isRepresentationClassReader()) { if (!(isFlavorCharsetTextType(flavor) && isTextFormat(format))) { throw new IOException (""cannot transfer non-text data as Reader""); } InputStream is = (InputStream)translateStreamToInputStream( str, DataFlavor.plainTextFlavor, format, localeTransferable); String unicode = DataTransferer.getTextCharset(DataFlavor.plainTextFlavor); Reader reader = new InputStreamReader(is, unicode); theObject = constructFlavoredObject(reader, flavor, Reader.class); // Target data is a byte array } else if (byte[].class.equals(flavor.getRepresentationClass())) { if(isFlavorCharsetTextType(flavor) && isTextFormat(format)) { theObject = translateBytesToString(inputStreamToByteArray(str), format, localeTransferable) .getBytes(DataTransferer.getTextCharset(flavor)); } else { theObject = inputStreamToByteArray(str); } // Target data is an RMI object } else if (flavor.isRepresentationClassRemote()) { try (ObjectInputStream ois = new ObjectInputStream(str)) { theObject = RMI.getMarshalledObject(ois.readObject()); }catch (Exception e) { throw new IOException(e.getMessage()); } // Target data is Serializable } else if (flavor.isRepresentationClassSerializable()) { try (ObjectInputStream ois = new ObjectInputStream(str)) { theObject = ois.readObject(); } catch (Exception e) { throw new IOException(e.getMessage()); } // Target data is Image } else if (DataFlavor.imageFlavor.equals(flavor)) { if (!isImageFormat(format)) { throw new IOException(""data translation failed""); } theObject = platformImageBytesToImage(inputStreamToByteArray(str), format); } if (theObject == null) { throw new IOException(""data translation failed""); } return theObject; } /** * For arbitrary flavors, just use the raw InputStream. For text flavors, * ReencodingInputStream will decode and reencode the InputStream on demand * so that we can strip terminators and search-and-replace EOLN. */ private Object translateStreamToInputStream (InputStream str, DataFlavor flavor, long format, Transferable localeTransferable) throws IOException { if (isFlavorCharsetTextType(flavor) && isTextFormat(format)) { str = new ReencodingInputStream (str, format, DataTransferer.getTextCharset(flavor), localeTransferable); } return constructFlavoredObject(str, flavor, InputStream.class); } /** * We support representations which are exactly of the specified Class, * and also arbitrary Objects which have a constructor which takes an * instance of the Class as its sole parameter. */ private Object constructFlavoredObject(Object arg, DataFlavor flavor, Class clazz) throws IOException { final Class dfrc = flavor.getRepresentationClass(); if (clazz.equals(dfrc)) { return arg; // simple case } else { Constructor[] constructors = null; try { constructors = (Constructor[]) AccessController.doPrivileged(new PrivilegedAction() { public Object run() { return dfrc.getConstructors(); } }); } catch (SecurityException se) { throw new IOException(se.getMessage()); } Constructor constructor = null; for (int j = 0; j < constructors.length; j++) { if (!Modifier.isPublic(constructors[j].getModifiers())) { continue; } Class[] ptypes = constructors[j].getParameterTypes(); if (ptypes != null && ptypes.length == 1 && clazz.equals(ptypes[0])) { constructor = constructors[j]; break; } } if (constructor == null) { throw new IOException(""can't find (L""+ clazz + "";)V for class: "" + dfrc.getName()); } try { return constructor.newInstance(new Object[] { arg } ); } catch (Exception e) { throw new IOException(e.getMessage()); } } } /** * Used for decoding and reencoding an InputStream on demand so that we * can strip NUL terminators and perform EOLN search-and-replace. */ public class ReencodingInputStream extends InputStream { protected BufferedReader wrapped; protected final char[] in = new char[2]; protected byte[] out; protected CharsetEncoder encoder; protected CharBuffer inBuf; protected ByteBuffer outBuf; protected char[] eoln; protected int numTerminators; protected boolean eos; protected int index, limit; public ReencodingInputStream(InputStream bytestream, long format, String targetEncoding, Transferable localeTransferable) throws IOException { Long lFormat = Long.valueOf(format); String sourceEncoding = null; if (isLocaleDependentTextFormat(format) && localeTransferable != null && localeTransferable. isDataFlavorSupported(javaTextEncodingFlavor)) { try { sourceEncoding = new String((byte[])localeTransferable. getTransferData(javaTextEncodingFlavor), ""UTF-8""); } catch (UnsupportedFlavorException cannotHappen) { } } else { sourceEncoding = getCharsetForTextFormat(lFormat); } if (sourceEncoding == null) { // Only happens when we have a custom text type. sourceEncoding = getDefaultTextCharset(); } wrapped = new BufferedReader (new InputStreamReader(bytestream, sourceEncoding)); if (targetEncoding == null) { // Throw NullPointerException for compatibility with the former // call to sun.io.CharToByteConverter.getConverter(null) // (Charset.forName(null) throws unspecified IllegalArgumentException // now; see 6228568) throw new NullPointerException(""null target encoding""); } try { encoder = Charset.forName(targetEncoding).newEncoder(); out = new byte[(int)(encoder.maxBytesPerChar() * 2 + 0.5)]; inBuf = CharBuffer.wrap(in); outBuf = ByteBuffer.wrap(out); } catch (IllegalCharsetNameException e) { throw new IOException(e.toString()); } catch (UnsupportedCharsetException e) { throw new IOException(e.toString()); } catch (UnsupportedOperationException e) { throw new IOException(e.toString()); } String sEoln = (String)nativeEOLNs.get(lFormat); if (sEoln != null) { eoln = sEoln.toCharArray(); } // A hope and a prayer that this works generically. This will // definitely work on Win32. Integer terminators = (Integer)nativeTerminators.get(lFormat); if (terminators != null) { numTerminators = terminators.intValue(); } } private int readChar() throws IOException { int c = wrapped.read(); if (c == -1) { // -1 is EOS eos = true; return -1; } // ""c == 0"" is not quite correct, but good enough on Windows. if (numTerminators > 0 && c == 0) { eos = true; return -1; } else if (eoln != null && matchCharArray(eoln, c)) { c = '\n' & 0xFFFF; } return c; } public int read() throws IOException { if (eos) { return -1; } if (index >= limit) { // deal with supplementary characters int c = readChar(); if (c == -1) { return -1; } in[0] = (char) c; in[1] = 0; inBuf.limit(1); if (Character.isHighSurrogate((char) c)) { c = readChar(); if (c != -1) { in[1] = (char) c; inBuf.limit(2); } } inBuf.rewind(); outBuf.limit(out.length).rewind(); encoder.encode(inBuf, outBuf, false); outBuf.flip(); limit = outBuf.limit(); index = 0; return read(); } else { return out[index++] & 0xFF; } } public int available() throws IOException { return ((eos) ? 0 : (limit - index)); } public void close() throws IOException { wrapped.close(); } /** * Checks to see if the next array.length characters in wrapped * match array. The first character is provided as c. Subsequent * characters are read from wrapped itself. When this method returns, * the wrapped index may be different from what it was when this * method was called. */ private boolean matchCharArray(char[] array, int c) throws IOException { wrapped.mark(array.length); // BufferedReader supports mark int count = 0; if ((char)c == array[0]) { for (count = 1; count < array.length; count++) { c = wrapped.read(); if (c == -1 || ((char)c) != array[count]) { break; } } } if (count == array.length) { return true; } else { wrapped.reset(); return false; } } } /** * Decodes a byte array into a set of String filenames. */ protected abstract String[] dragQueryFile(byte[] bytes); /** * Decodes URIs from either a byte array or a stream. */ protected URI[] dragQueryURIs(InputStream stream, long format, Transferable localeTransferable) throws IOException { throw new IOException( new UnsupportedOperationException(""not implemented on this platform"")); } /** * Translates either a byte array or an input stream which contain * platform-specific image data in the given format into an Image. */ protected abstract Image platformImageBytesToImage( byte[] bytes,long format) throws IOException; /** * Translates either a byte array or an input stream which contain * an image data in the given standard format into an Image. * * @param mimeType image MIME type, such as: image/png, image/jpeg, image/gif */ protected Image standardImageBytesToImage( byte[] bytes, String mimeType) throws IOException { Iterator readerIterator = ImageIO.getImageReadersByMIMEType(mimeType); if (!readerIterator.hasNext()) { throw new IOException(""No registered service provider can decode "" + "" an image from "" + mimeType); } IOException ioe = null; while (readerIterator.hasNext()) { ImageReader imageReader = (ImageReader)readerIterator.next(); try (ByteArrayInputStream bais = new ByteArrayInputStream(bytes)) { ImageInputStream imageInputStream = ImageIO.createImageInputStream(bais); try { ImageReadParam param = imageReader.getDefaultReadParam(); imageReader.setInput(imageInputStream, true, true); BufferedImage bufferedImage = imageReader.read(imageReader.getMinIndex(), param); if (bufferedImage != null) { return bufferedImage; } } finally { imageInputStream.close(); imageReader.dispose(); } } catch (IOException e) { ioe = e; continue; } } if (ioe == null) { ioe = new IOException(""Registered service providers failed to decode"" + "" an image from "" + mimeType); } throw ioe; } /** * Translates a Java Image into a byte array which contains platform- * specific image data in the given format. */ protected abstract byte[] imageToPlatformBytes(Image image, long format) throws IOException; /** * Translates a Java Image into a byte array which contains * an image data in the given standard format. * * @param mimeType image MIME type, such as: image/png, image/jpeg */ protected byte[] imageToStandardBytes(Image image, String mimeType) throws IOException { IOException originalIOE = null; Iterator writerIterator = ImageIO.getImageWritersByMIMEType(mimeType); if (!writerIterator.hasNext()) { throw new IOException(""No registered service provider can encode "" + "" an image to "" + mimeType); } if (image instanceof RenderedImage) { // Try to encode the original image. try { return imageToStandardBytesImpl((RenderedImage)image, mimeType); } catch (IOException ioe) { originalIOE = ioe; } } // Retry with a BufferedImage. int width = 0; int height = 0; if (image instanceof ToolkitImage) { ImageRepresentation ir = ((ToolkitImage)image).getImageRep(); ir.reconstruct(ImageObserver.ALLBITS); width = ir.getWidth(); height = ir.getHeight(); } else { width = image.getWidth(null); height = image.getHeight(null); } ColorModel model = ColorModel.getRGBdefault(); WritableRaster raster = model.createCompatibleWritableRaster(width, height); BufferedImage bufferedImage = new BufferedImage(model, raster, model.isAlphaPremultiplied(), null); Graphics g = bufferedImage.getGraphics(); try { g.drawImage(image, 0, 0, width, height, null); } finally { g.dispose(); } try { return imageToStandardBytesImpl(bufferedImage, mimeType); } catch (IOException ioe) { if (originalIOE != null) { throw originalIOE; } else { throw ioe; } } } protected byte[] imageToStandardBytesImpl(RenderedImage renderedImage, String mimeType) throws IOException { Iterator writerIterator = ImageIO.getImageWritersByMIMEType(mimeType); ImageTypeSpecifier typeSpecifier = new ImageTypeSpecifier(renderedImage); ByteArrayOutputStream baos = new ByteArrayOutputStream(); IOException ioe = null; while (writerIterator.hasNext()) { ImageWriter imageWriter = (ImageWriter)writerIterator.next(); ImageWriterSpi writerSpi = imageWriter.getOriginatingProvider(); if (!writerSpi.canEncodeImage(typeSpecifier)) { continue; } try { ImageOutputStream imageOutputStream = ImageIO.createImageOutputStream(baos); try { imageWriter.setOutput(imageOutputStream); imageWriter.write(renderedImage); imageOutputStream.flush(); } finally { imageOutputStream.close(); } } catch (IOException e) { imageWriter.dispose(); baos.reset(); ioe = e; continue; } imageWriter.dispose(); baos.close(); return baos.toByteArray(); } baos.close(); if (ioe == null) { ioe = new IOException(""Registered service providers failed to encode "" + renderedImage + "" to "" + mimeType); } throw ioe; } /** * Concatenates the data represented by two objects. Objects can be either * byte arrays or instances of InputStream. If both arguments * are byte arrays byte array will be returned. Otherwise an * InputStream will be returned. *

* Currently is only called from native code to prepend palette data to * platform-specific image data during image transfer on Win32. * * @param obj1 the first object to be concatenated. * @param obj2 the second object to be concatenated. * @return a byte array or an InputStream which represents * a logical concatenation of the two arguments. * @throws NullPointerException is either of the arguments is * null * @throws ClassCastException is either of the arguments is * neither byte array nor an instance of InputStream. */ private Object concatData(Object obj1, Object obj2) { InputStream str1 = null; InputStream str2 = null; if (obj1 instanceof byte[]) { byte[] arr1 = (byte[])obj1; if (obj2 instanceof byte[]) { byte[] arr2 = (byte[])obj2; byte[] ret = new byte[arr1.length + arr2.length]; System.arraycopy(arr1, 0, ret, 0, arr1.length); System.arraycopy(arr2, 0, ret, arr1.length, arr2.length); return ret; } else { str1 = new ByteArrayInputStream(arr1); str2 = (InputStream)obj2; } } else { str1 = (InputStream)obj1; if (obj2 instanceof byte[]) { str2 = new ByteArrayInputStream((byte[])obj2); } else { str2 = (InputStream)obj2; } } return new SequenceInputStream(str1, str2); } public byte[] convertData(final Object source, final Transferable contents, final long format, final Map formatMap, final boolean isToolkitThread) throws IOException { byte[] ret = null; /* * If the current thread is the Toolkit thread we should post a * Runnable to the event dispatch thread associated with source Object, * since translateTransferable() calls Transferable.getTransferData() * that may contain client code. */ if (isToolkitThread) try { final Stack stack = new Stack(); final Runnable dataConverter = new Runnable() { // Guard against multiple executions. private boolean done = false; public void run() { if (done) { return; } byte[] data = null; try { DataFlavor flavor = (DataFlavor)formatMap.get(Long.valueOf(format)); if (flavor != null) { data = translateTransferable(contents, flavor, format); } } catch (Exception e) { e.printStackTrace(); data = null; } try { getToolkitThreadBlockedHandler().lock(); stack.push(data); getToolkitThreadBlockedHandler().exit(); } finally { getToolkitThreadBlockedHandler().unlock(); done = true; } } }; final AppContext appContext = SunToolkit.targetToAppContext(source); getToolkitThreadBlockedHandler().lock(); if (appContext != null) { appContext.put(DATA_CONVERTER_KEY, dataConverter); } SunToolkit.executeOnEventHandlerThread(source, dataConverter); while (stack.empty()) { getToolkitThreadBlockedHandler().enter(); } if (appContext != null) { appContext.remove(DATA_CONVERTER_KEY); } ret = (byte[])stack.pop(); } finally { getToolkitThreadBlockedHandler().unlock(); } else { DataFlavor flavor = (DataFlavor) formatMap.get(Long.valueOf(format)); if (flavor != null) { ret = translateTransferable(contents, flavor, format); } } return ret; } public void processDataConversionRequests() { if (EventQueue.isDispatchThread()) { AppContext appContext = AppContext.getAppContext(); getToolkitThreadBlockedHandler().lock(); try { Runnable dataConverter = (Runnable)appContext.get(DATA_CONVERTER_KEY); if (dataConverter != null) { dataConverter.run(); appContext.remove(DATA_CONVERTER_KEY); } } finally { getToolkitThreadBlockedHandler().unlock(); } } } public abstract ToolkitThreadBlockedHandler getToolkitThreadBlockedHandler(); /** * Helper function to reduce a Map with Long keys to a long array. *

* The map keys are sorted according to the native formats preference * order. */ public static long[] keysToLongArray(SortedMap map) { Set keySet = map.keySet(); long[] retval = new long[keySet.size()]; int i = 0; for (Iterator iter = keySet.iterator(); iter.hasNext(); i++) { retval[i] = ((Long)iter.next()).longValue(); } return retval; } /** * Helper function to convert a Set of DataFlavors to a sorted array. * The array will be sorted according to DataFlavorComparator. */ public static DataFlavor[] setToSortedDataFlavorArray(Set flavorsSet) { DataFlavor[] flavors = new DataFlavor[flavorsSet.size()]; flavorsSet.toArray(flavors); final Comparator comparator = new DataFlavorComparator(IndexedComparator.SELECT_WORST); Arrays.sort(flavors, comparator); return flavors; } /** * Helper function to convert an InputStream to a byte[] array. */ protected static byte[] inputStreamToByteArray(InputStream str) throws IOException { try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) { int len = 0; byte[] buf = new byte[8192]; while ((len = str.read(buf)) != -1) { baos.write(buf, 0, len); } return baos.toByteArray(); } } /** * Returns platform-specific mappings for the specified native. * If there are no platform-specific mappings for this native, the method * returns an empty List. */ public List getPlatformMappingsForNative(String nat) { return new ArrayList(); } /** * Returns platform-specific mappings for the specified flavor. * If there are no platform-specific mappings for this flavor, the method * returns an empty List. */ public List getPlatformMappingsForFlavor(DataFlavor df) { return new ArrayList(); } /** * A Comparator which includes a helper function for comparing two Objects * which are likely to be keys in the specified Map. */ public abstract static class IndexedComparator implements Comparator { /** * The best Object (e.g., DataFlavor) will be the last in sequence. */ public static final boolean SELECT_BEST = true; /** * The best Object (e.g., DataFlavor) will be the first in sequence. */ public static final boolean SELECT_WORST = false; protected final boolean order; public IndexedComparator() { this(SELECT_BEST); } public IndexedComparator(boolean order) { this.order = order; } /** * Helper method to compare two objects by their Integer indices in the * given map. If the map doesn't contain an entry for either of the * objects, the fallback index will be used for the object instead. * * @param indexMap the map which maps objects into Integer indexes. * @param obj1 the first object to be compared. * @param obj2 the second object to be compared. * @param fallbackIndex the Integer to be used as a fallback index. * @return a negative integer, zero, or a positive integer as the * first object is mapped to a less, equal to, or greater * index than the second. */ protected static int compareIndices(Map indexMap, Object obj1, Object obj2, Integer fallbackIndex) { Integer index1 = (Integer)indexMap.get(obj1); Integer index2 = (Integer)indexMap.get(obj2); if (index1 == null) { index1 = fallbackIndex; } if (index2 == null) { index2 = fallbackIndex; } return index1.compareTo(index2); } /** * Helper method to compare two objects by their Long indices in the * given map. If the map doesn't contain an entry for either of the * objects, the fallback index will be used for the object instead. * * @param indexMap the map which maps objects into Long indexes. * @param obj1 the first object to be compared. * @param obj2 the second object to be compared. * @param fallbackIndex the Long to be used as a fallback index. * @return a negative integer, zero, or a positive integer as the * first object is mapped to a less, equal to, or greater * index than the second. */ protected static int compareLongs(Map indexMap, Object obj1, Object obj2, Long fallbackIndex) { Long index1 = (Long)indexMap.get(obj1); Long index2 = (Long)indexMap.get(obj2); if (index1 == null) { index1 = fallbackIndex; } if (index2 == null) { index2 = fallbackIndex; } return index1.compareTo(index2); } } /** * An IndexedComparator which compares two String charsets. The comparison * follows the rules outlined in DataFlavor.selectBestTextFlavor. In order * to ensure that non-Unicode, non-ASCII, non-default charsets are sorted * in alphabetical order, charsets are not automatically converted to their * canonical forms. */ public static class CharsetComparator extends IndexedComparator { private static final Map charsets; private static String defaultEncoding; private static final Integer DEFAULT_CHARSET_INDEX = Integer.valueOf(2); private static final Integer OTHER_CHARSET_INDEX = Integer.valueOf(1); private static final Integer WORST_CHARSET_INDEX = Integer.valueOf(0); private static final Integer UNSUPPORTED_CHARSET_INDEX = Integer.valueOf(Integer.MIN_VALUE); private static final String UNSUPPORTED_CHARSET = ""UNSUPPORTED""; static { HashMap charsetsMap = new HashMap(8, 1.0f); // we prefer Unicode charsets charsetsMap.put(canonicalName(""UTF-16LE""), Integer.valueOf(4)); charsetsMap.put(canonicalName(""UTF-16BE""), Integer.valueOf(5)); charsetsMap.put(canonicalName(""UTF-8""), Integer.valueOf(6)); charsetsMap.put(canonicalName(""UTF-16""), Integer.valueOf(7)); // US-ASCII is the worst charset supported charsetsMap.put(canonicalName(""US-ASCII""), WORST_CHARSET_INDEX); String defEncoding = DataTransferer.canonicalName (DataTransferer.getDefaultTextCharset()); if (charsetsMap.get(defaultEncoding) == null) { charsetsMap.put(defaultEncoding, DEFAULT_CHARSET_INDEX); } charsetsMap.put(UNSUPPORTED_CHARSET, UNSUPPORTED_CHARSET_INDEX); charsets = Collections.unmodifiableMap(charsetsMap); } public CharsetComparator() { this(SELECT_BEST); } public CharsetComparator(boolean order) { super(order); } /** * Compares two String objects. Returns a negative integer, zero, * or a positive integer as the first charset is worse than, equal to, * or better than the second. * * @param obj1 the first charset to be compared * @param obj2 the second charset to be compared * @return a negative integer, zero, or a positive integer as the * first argument is worse, equal to, or better than the * second. * @throws ClassCastException if either of the arguments is not * instance of String * @throws NullPointerException if either of the arguments is * null. */ public int compare(Object obj1, Object obj2) { String charset1 = null; String charset2 = null; if (order == SELECT_BEST) { charset1 = (String)obj1; charset2 = (String)obj2; } else { charset1 = (String)obj2; charset2 = (String)obj1; } return compareCharsets(charset1, charset2); } /** * Compares charsets. Returns a negative integer, zero, or a positive * integer as the first charset is worse than, equal to, or better than * the second. *

* Charsets are ordered according to the following rules: *

    *
  • All unsupported charsets are equal. *
  • Any unsupported charset is worse than any supported charset. *
  • Unicode charsets, such as ""UTF-16"", ""UTF-8"", ""UTF-16BE"" and * ""UTF-16LE"", are considered best. *
  • After them, platform default charset is selected. *
  • ""US-ASCII"" is the worst of supported charsets. *
  • For all other supported charsets, the lexicographically less * one is considered the better. *
* * @param charset1 the first charset to be compared * @param charset2 the second charset to be compared. * @return a negative integer, zero, or a positive integer as the * first argument is worse, equal to, or better than the * second. */ protected int compareCharsets(String charset1, String charset2) { charset1 = getEncoding(charset1); charset2 = getEncoding(charset2); int comp = compareIndices(charsets, charset1, charset2, OTHER_CHARSET_INDEX); if (comp == 0) { return charset2.compareTo(charset1); } return comp; } /** * Returns encoding for the specified charset according to the * following rules: *
    *
  • If the charset is null, then null will * be returned. *
  • Iff the charset specifies an encoding unsupported by this JRE, * UNSUPPORTED_CHARSET will be returned. *
  • If the charset specifies an alias name, the corresponding * canonical name will be returned iff the charset is a known * Unicode, ASCII, or default charset. *
* * @param charset the charset. * @return an encoding for this charset. */ protected static String getEncoding(String charset) { if (charset == null) { return null; } else if (!DataTransferer.isEncodingSupported(charset)) { return UNSUPPORTED_CHARSET; } else { // Only convert to canonical form if the charset is one // of the charsets explicitly listed in the known charsets // map. This will happen only for Unicode, ASCII, or default // charsets. String canonicalName = DataTransferer.canonicalName(charset); return (charsets.containsKey(canonicalName)) ? canonicalName : charset; } } } /** * An IndexedComparator which compares two DataFlavors. For text flavors, * the comparison follows the rules outlined in * DataFlavor.selectBestTextFlavor. For non-text flavors, unknown * application MIME types are preferred, followed by known * application/x-java-* MIME types. Unknown application types are preferred * because if the user provides his own data flavor, it will likely be the * most descriptive one. For flavors which are otherwise equal, the * flavors' string representation are compared in the alphabetical order. */ public static class DataFlavorComparator extends IndexedComparator { private final CharsetComparator charsetComparator; private static final Map exactTypes; private static final Map primaryTypes; private static final Map nonTextRepresentations; private static final Map textTypes; private static final Map decodedTextRepresentations; private static final Map encodedTextRepresentations; private static final Integer UNKNOWN_OBJECT_LOSES = Integer.valueOf(Integer.MIN_VALUE); private static final Integer UNKNOWN_OBJECT_WINS = Integer.valueOf(Integer.MAX_VALUE); private static final Long UNKNOWN_OBJECT_LOSES_L = Long.valueOf(Long.MIN_VALUE); private static final Long UNKNOWN_OBJECT_WINS_L = Long.valueOf(Long.MAX_VALUE); static { { HashMap exactTypesMap = new HashMap(4, 1.0f); // application/x-java-* MIME types exactTypesMap.put(""application/x-java-file-list"", Integer.valueOf(0)); exactTypesMap.put(""application/x-java-serialized-object"", Integer.valueOf(1)); exactTypesMap.put(""application/x-java-jvm-local-objectref"", Integer.valueOf(2)); exactTypesMap.put(""application/x-java-remote-object"", Integer.valueOf(3)); exactTypes = Collections.unmodifiableMap(exactTypesMap); } { HashMap primaryTypesMap = new HashMap(1, 1.0f); primaryTypesMap.put(""application"", Integer.valueOf(0)); primaryTypes = Collections.unmodifiableMap(primaryTypesMap); } { HashMap nonTextRepresentationsMap = new HashMap(3, 1.0f); nonTextRepresentationsMap.put(java.io.InputStream.class, Integer.valueOf(0)); nonTextRepresentationsMap.put(java.io.Serializable.class, Integer.valueOf(1)); Class remoteClass = RMI.remoteClass(); if (remoteClass != null) { nonTextRepresentationsMap.put(remoteClass, Integer.valueOf(2)); } nonTextRepresentations = Collections.unmodifiableMap(nonTextRepresentationsMap); } { HashMap textTypesMap = new HashMap(16, 1.0f); // plain text textTypesMap.put(""text/plain"", Integer.valueOf(0)); // stringFlavor textTypesMap.put(""application/x-java-serialized-object"", Integer.valueOf(1)); // misc textTypesMap.put(""text/calendar"", Integer.valueOf(2)); textTypesMap.put(""text/css"", Integer.valueOf(3)); textTypesMap.put(""text/directory"", Integer.valueOf(4)); textTypesMap.put(""text/parityfec"", Integer.valueOf(5)); textTypesMap.put(""text/rfc822-headers"", Integer.valueOf(6)); textTypesMap.put(""text/t140"", Integer.valueOf(7)); textTypesMap.put(""text/tab-separated-values"", Integer.valueOf(8)); textTypesMap.put(""text/uri-list"", Integer.valueOf(9)); // enriched textTypesMap.put(""text/richtext"", Integer.valueOf(10)); textTypesMap.put(""text/enriched"", Integer.valueOf(11)); textTypesMap.put(""text/rtf"", Integer.valueOf(12)); // markup textTypesMap.put(""text/html"", Integer.valueOf(13)); textTypesMap.put(""text/xml"", Integer.valueOf(14)); textTypesMap.put(""text/sgml"", Integer.valueOf(15)); textTypes = Collections.unmodifiableMap(textTypesMap); } { HashMap decodedTextRepresentationsMap = new HashMap(4, 1.0f); decodedTextRepresentationsMap.put (char[].class, Integer.valueOf(0)); decodedTextRepresentationsMap.put (java.nio.CharBuffer.class, Integer.valueOf(1)); decodedTextRepresentationsMap.put (java.lang.String.class, Integer.valueOf(2)); decodedTextRepresentationsMap.put (java.io.Reader.class, Integer.valueOf(3)); decodedTextRepresentations = Collections.unmodifiableMap(decodedTextRepresentationsMap); } { HashMap encodedTextRepresentationsMap = new HashMap(3, 1.0f); encodedTextRepresentationsMap.put (byte[].class, Integer.valueOf(0)); encodedTextRepresentationsMap.put (java.nio.ByteBuffer.class, Integer.valueOf(1)); encodedTextRepresentationsMap.put (java.io.InputStream.class, Integer.valueOf(2)); encodedTextRepresentations = Collections.unmodifiableMap(encodedTextRepresentationsMap); } } public DataFlavorComparator() { this(SELECT_BEST); } public DataFlavorComparator(boolean order) { super(order); charsetComparator = new CharsetComparator(order); } public int compare(Object obj1, Object obj2) { DataFlavor flavor1 = null; DataFlavor flavor2 = null; if (order == SELECT_BEST) { flavor1 = (DataFlavor)obj1; flavor2 = (DataFlavor)obj2; } else { flavor1 = (DataFlavor)obj2; flavor2 = (DataFlavor)obj1; } if (flavor1.equals(flavor2)) { return 0; } int comp = 0; String primaryType1 = flavor1.getPrimaryType(); String subType1 = flavor1.getSubType(); String mimeType1 = primaryType1 + ""/"" + subType1; Class class1 = flavor1.getRepresentationClass(); String primaryType2 = flavor2.getPrimaryType(); String subType2 = flavor2.getSubType(); String mimeType2 = primaryType2 + ""/"" + subType2; Class class2 = flavor2.getRepresentationClass(); if (flavor1.isFlavorTextType() && flavor2.isFlavorTextType()) { // First, compare MIME types comp = compareIndices(textTypes, mimeType1, mimeType2, UNKNOWN_OBJECT_LOSES); if (comp != 0) { return comp; } // Only need to test one flavor because they both have the // same MIME type. Also don't need to worry about accidentally // passing stringFlavor because either // 1. Both flavors are stringFlavor, in which case the // equality test at the top of the function succeeded. // 2. Only one flavor is stringFlavor, in which case the MIME // type comparison returned a non-zero value. if (doesSubtypeSupportCharset(flavor1)) { // Next, prefer the decoded text representations of Reader, // String, CharBuffer, and [C, in that order. comp = compareIndices(decodedTextRepresentations, class1, class2, UNKNOWN_OBJECT_LOSES); if (comp != 0) { return comp; } // Next, compare charsets comp = charsetComparator.compareCharsets (DataTransferer.getTextCharset(flavor1), DataTransferer.getTextCharset(flavor2)); if (comp != 0) { return comp; } } // Finally, prefer the encoded text representations of // InputStream, ByteBuffer, and [B, in that order. comp = compareIndices(encodedTextRepresentations, class1, class2, UNKNOWN_OBJECT_LOSES); if (comp != 0) { return comp; } } else { // First, prefer application types. comp = compareIndices(primaryTypes, primaryType1, primaryType2, UNKNOWN_OBJECT_LOSES); if (comp != 0) { return comp; } // Next, look for application/x-java-* types. Prefer unknown // MIME types because if the user provides his own data flavor, // it will likely be the most descriptive one. comp = compareIndices(exactTypes, mimeType1, mimeType2, UNKNOWN_OBJECT_WINS); if (comp != 0) { return comp; } // Finally, prefer the representation classes of Remote, // Serializable, and InputStream, in that order. comp = compareIndices(nonTextRepresentations, class1, class2, UNKNOWN_OBJECT_LOSES); if (comp != 0) { return comp; } } // The flavours are not equal but still not distinguishable. // Compare String representations in alphabetical order return flavor1.getMimeType().compareTo(flavor2.getMimeType()); } } /* * Given the Map that maps objects to Integer indices and a boolean value, * this Comparator imposes a direct or reverse order on set of objects. *

* If the specified boolean value is SELECT_BEST, the Comparator imposes the * direct index-based order: an object A is greater than an object B if and * only if the index of A is greater than the index of B. An object that * doesn't have an associated index is less or equal than any other object. *

* If the specified boolean value is SELECT_WORST, the Comparator imposes the * reverse index-based order: an object A is greater than an object B if and * only if A is less than B with the direct index-based order. */ public static class IndexOrderComparator extends IndexedComparator { private final Map indexMap; private static final Integer FALLBACK_INDEX = Integer.valueOf(Integer.MIN_VALUE); public IndexOrderComparator(Map indexMap) { super(SELECT_BEST); this.indexMap = indexMap; } public IndexOrderComparator(Map indexMap, boolean order) { super(order); this.indexMap = indexMap; } public int compare(Object obj1, Object obj2) { if (order == SELECT_WORST) { return -compareIndices(indexMap, obj1, obj2, FALLBACK_INDEX); } else { return compareIndices(indexMap, obj1, obj2, FALLBACK_INDEX); } } } /** * A class that provides access to java.rmi.Remote and java.rmi.MarshalledObject * without creating a static dependency. */ private static class RMI { private static final Class remoteClass = getClass(""java.rmi.Remote""); private static final Class marshallObjectClass = getClass(""java.rmi.MarshalledObject""); private static final Constructor marshallCtor = getConstructor(marshallObjectClass, Object.class); private static final Method marshallGet = getMethod(marshallObjectClass, ""get""); private static Class getClass(String name) { try { return Class.forName(name, true, null); } catch (ClassNotFoundException e) { return null; } } private static Constructor getConstructor(Class c, Class... types) { try { return (c == null) ? null : c.getDeclaredConstructor(types); } catch (NoSuchMethodException x) { throw new AssertionError(x); } } private static Method getMethod(Class c, String name, Class... types) { try { return (c == null) ? null : c.getMethod(name, types); } catch (NoSuchMethodException e) { throw new AssertionError(e); } } /** * Returns {@code true} if the given class is java.rmi.Remote. */ static boolean isRemote(Class c) { return (remoteClass == null) ? null : remoteClass.isAssignableFrom(c); } /** * Returns java.rmi.Remote.class if RMI is present; otherwise {@code null}. */ static Class remoteClass() { return remoteClass; } /** * Returns a new MarshalledObject containing the serialized representation * of the given object. */ static Object newMarshalledObject(Object obj) throws IOException { try { return marshallCtor.newInstance(obj); } catch (InstantiationException x) { throw new AssertionError(x); } catch (IllegalAccessException x) { throw new AssertionError(x); } catch (InvocationTargetException x) { Throwable cause = x.getCause(); if (cause instanceof IOException) throw (IOException)cause; throw new AssertionError(x); } } /** * Returns a new copy of the contained marshalled object. */ static Object getMarshalledObject(Object obj) throws IOException, ClassNotFoundException { try { return marshallGet.invoke(obj); } catch (IllegalAccessException x) { throw new AssertionError(x); } catch (InvocationTargetException x) { Throwable cause = x.getCause(); if (cause instanceof IOException) throw (IOException)cause; if (cause instanceof ClassNotFoundException) throw (ClassNotFoundException)cause; throw new AssertionError(x); } } } } ",koutheir/incinerator-hotspot,jdk/src/share/classes/sun/awt/datatransfer/DataTransferer.java,Java,gpl-2.0,117504 4,"/* * Copyright (c) 2012-2018 Red Hat, Inc. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * Red Hat, Inc. - initial API and implementation */ package org.eclipse.che.account.api; import com.google.inject.AbstractModule; import org.eclipse.che.account.spi.AccountDao; import org.eclipse.che.account.spi.jpa.JpaAccountDao; /** @author Sergii Leschenko */ public class AccountModule extends AbstractModule { @Override protected void configure() { bind(AccountDao.class).to(JpaAccountDao.class); } } ",sleshchenko/che,wsmaster/che-core-api-account/src/main/java/org/eclipse/che/account/api/AccountModule.java,Java,epl-1.0,732 5,"#!/usr/bin/env python2.5 # # Copyright 2009 the Melange authors. # # Licensed under the Apache License, Version 2.0 (the ""License""); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an ""AS IS"" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """"""GHOPTask (Model) query functions. """""" __authors__ = [ '""Madhusudan.C.S"" ', '""Daniel Hans"" ', '""Lennard de Rijk"" ', ] import datetime from google.appengine.ext import db from django.utils import simplejson from django.utils.translation import ugettext from soc.logic.models import base from soc.logic import tags from soc.modules.ghop.logic.models import comment as ghop_comment_logic import soc.models.linkable import soc.modules.ghop.logic.models.organization import soc.modules.ghop.models.task STATE_TRANSITIONS = { 'Claimed': 'transitFromClaimed', 'NeedsReview': 'transitFromNeedsReview', 'ActionNeeded': 'transitFromActionNeeded', 'NeedsWork': 'transitFromNeedsWork', } TAG_NAMES = ['arbit_tag', 'difficulty', 'task_type'] class Logic(base.Logic): """"""Logic methods for the GHOPTask model. """""" DEF_ACTION_NEEDED_MSG = ugettext( '(The Melange Automated System has detected that the intial ' 'deadline has been passed and it has set the task status to ' 'ActionNeeded.)') DEF_NO_MORE_WORK_MSG = ugettext( '(The Melange Automated System has detected that the deadline ' 'has been passed and no more work can be submitted.)') DEF_REOPENED_MSG = ugettext( '(The Melange Automated System has detected that the final ' 'deadline has been passed and it has Reopened the task.)') def __init__(self, model=soc.modules.ghop.models.task.GHOPTask, base_model=soc.models.linkable.Linkable, scope_logic=soc.modules.ghop.logic.models.organization): """"""Defines the name, key_name and model for this entity. """""" self.tags_service = tags.TagsService(TAG_NAMES) super(Logic, self).__init__(model, base_model=base_model, scope_logic=scope_logic) def updateEntityProperties(self, entity, entity_properties, silent=False, store=True): """"""See base.Logic.updateEntityProperties(). Also ensures that the history property of the task is updated in the same datastore operation. """""" # TODO: History needs a proper test drive and perhaps a refactoring history = {} # we construct initial snapshot of the task when it is published # for the first time. if entity_properties and 'status' in entity_properties: if entity.status == 'Unpublished' or entity.status == 'Unapproved': if entity_properties['status'] == 'Open': history = { 'title': entity.title, 'description': entity.description, 'difficulty': entity.difficulty[0].tag, 'task_type': [type.tag for type in entity.task_type], 'time_to_complete': entity.time_to_complete, 'mentors': [m_key.name() for m_key in entity.mentors], 'user': '', 'student': '', 'status': entity.status, 'deadline': '', 'created_by': entity.created_by.key().name(), 'created_on': str(entity.created_on), 'modified_on': str(entity.modified_on), } if entity.modified_by: history['modified_by'] = entity.modified_by.key().name() # initialize history task_history = {} # extract the existing json history from the entity to update it elif entity.history: task_history = simplejson.loads(entity.history) else: task_history = {} # we construct history for only changed entity properties if entity_properties: for property in entity_properties: changed_val = getattr(entity, property) if changed_val != entity_properties[property]: if property == 'deadline': history[property] = str(changed_val) else: history[property] = changed_val if history: # create a dictionary for the new history update with timestamp as key tstamp = str(datetime.datetime.now()) new_history = {tstamp: history} # update existing history task_history.update(new_history) task_history_str = simplejson.dumps(task_history) # update the task's history property history_property = { 'history': task_history_str } entity_properties.update(history_property) entity = self.tags_service.setTagValuesForEntity(entity, entity_properties) # call the base logic method to store the updated Task entity return super(Logic, self).updateEntityProperties( entity, entity_properties, silent=silent, store=store) def updateEntityPropertiesWithCWS(self, entity, entity_properties, comment_properties=None, ws_properties=None, silent=False): """"""Updates the GHOPTask entity properties and creates a comment entity. Args: entity: a model entity entity_properties: keyword arguments that correspond to entity properties and their values comment_properties: keyword arguments that correspond to the GHOPTask's to be created comment entity silent: iff True does not call post store methods. """""" # pylint: disable-msg=W0621 from soc.modules.ghop.logic.models.comment import logic as \ ghop_comment_logic from soc.modules.ghop.logic.models.work_submission import logic as \ ghop_work_submission_logic from soc.modules.ghop.models import comment as ghop_comment_model from soc.modules.ghop.models import work_submission as \ ghop_work_submission_model if entity_properties: entity = self.updateEntityProperties(entity, entity_properties, silent=silent, store=False) comment_entity = ghop_comment_model.GHOPComment(**comment_properties) ws_entity = None if ws_properties: ws_entity = ghop_work_submission_model.GHOPWorkSubmission( **ws_properties) def comment_create(): """"""Method to be run in transaction that stores Task, Comment and WorkSubmission. """""" entity.put() if ws_entity: ws_entity.put() comment_entity.content = comment_entity.content % ( ws_entity.key().id_or_name()) comment_entity.put() return entity, comment_entity, ws_entity else: comment_entity.put() return entity, comment_entity, None entity, comment_entity, ws_entity = db.run_in_transaction( comment_create) if not silent: # call the _onCreate methods for the Comment and WorkSubmission if comment_entity: ghop_comment_logic._onCreate(comment_entity) if ws_entity: ghop_work_submission_logic._onCreate(ws_entity) return entity, comment_entity, ws_entity def updateOrCreateFromFields(self, properties, silent=False): """"""See base.Logic.updateOrCreateFromFields(). """""" # TODO: History needs to be tested and perhaps refactored if properties.get('status') == 'Open': history = { 'title': properties['title'], 'description': properties['description'], 'difficulty': properties['difficulty']['tags'], 'task_type': properties['type_tags'], 'time_to_complete': properties['time_to_complete'], 'mentors': [m_key.name() for m_key in properties['mentors']], 'user': '', 'student': '', 'status': properties['status'], 'deadline': '', 'created_on': str(properties['created_on']), 'modified_on': str(properties['modified_on']), } if 'created_by' in properties and properties['created_by']: history['created_by'] = properties['created_by'].key().name() history['modified_by'] = properties['modified_by'].key().name() # Constructs new history from the _constructNewHistory method, assigns # it as a value to the dictionary key with current timestamp and dumps # a JSON string. task_history_str = simplejson.dumps({ str(datetime.datetime.now()): history, }) # update the task's history property history_property = { 'history': task_history_str } properties.update(history_property) entity = super(Logic, self).updateOrCreateFromFields(properties, silent) self.tags_service.setTagValuesForEntity(entity, properties) return entity def getFromKeyFieldsWithCWSOr404(self, fields): """"""Returns the Task, all Comments and all WorkSubmissions for the Task specified by the fields argument. For args see base.getFromKeyFieldsOr404(). """""" # pylint: disable-msg=W0621 from soc.modules.ghop.logic.models.comment import logic as \ ghop_comment_logic from soc.modules.ghop.logic.models.work_submission import logic as \ ghop_work_submission_logic entity = self.getFromKeyFieldsOr404(fields) comment_entities = ghop_comment_logic.getForFields( ancestors=[entity], order=['created_on']) ws_entities = ghop_work_submission_logic.getForFields( ancestors=[entity], order=['submitted_on']) return entity, comment_entities, ws_entities def updateTaskStatus(self, entity): """"""Method used to transit a task from a state to another state depending on the context. Whenever the deadline has passed. Args: entity: The GHOPTask entity Returns: Task entity and a Comment entity if the occurring transit created one. """""" from soc.modules.ghop.tasks import task_update if entity.deadline and datetime.datetime.now() > entity.deadline: # calls a specific method to make a transition depending on the # task's current state transit_func = getattr(self, STATE_TRANSITIONS[entity.status]) update_dict = transit_func(entity) comment_properties = { 'parent': entity, 'scope_path': entity.key().name(), 'created_by': None, 'content': update_dict['content'], 'changes': update_dict['changes'], } entity, comment_entity, _ = self.updateEntityPropertiesWithCWS( entity, update_dict['properties'], comment_properties) if entity.deadline: # only if there is a deadline set we should schedule another task task_update.spawnUpdateTask(entity) else: comment_entity = None return entity, comment_entity def transitFromClaimed(self, entity): """"""Makes a state transition of a GHOP Task from Claimed state to a relevant state. Args: entity: The GHOPTask entity """""" # deadline is extended by 24 hours. deadline = entity.deadline + datetime.timedelta( hours=24) properties = { 'status': 'ActionNeeded', 'deadline': deadline, } changes = [ugettext('User-MelangeAutomatic'), ugettext('Action-Warned for action'), ugettext('Status-%s' % (properties['status']))] content = self.DEF_ACTION_NEEDED_MSG update_dict = { 'properties': properties, 'changes': changes, 'content': content, } return update_dict def transitFromNeedsReview(self, entity): """"""Makes a state transition of a GHOP Task from NeedsReview state to a relevant state. Args: entity: The GHOPTask entity """""" properties = { 'deadline': None, } changes = [ugettext('User-MelangeAutomatic'), ugettext('Action-Deadline passed'), ugettext('Status-%s' % (entity.status))] content = self.DEF_NO_MORE_WORK_MSG update_dict = { 'properties': properties, 'changes': changes, 'content': content, } return update_dict def transitFromActionNeeded(self, entity): """"""Makes a state transition of a GHOP Task from ActionNeeded state to a relevant state. Args: entity: The GHOPTask entity """""" properties = { 'user': None, 'student': None, 'status': 'Reopened', 'deadline': None, } changes = [ugettext('User-MelangeAutomatic'), ugettext('Action-Forcibly reopened'), ugettext('Status-Reopened')] content = self.DEF_REOPENED_MSG update_dict = { 'properties': properties, 'changes': changes, 'content': content, } return update_dict def transitFromNeedsWork(self, entity): """"""Makes a state transition of a GHOP Task from NeedsWork state to a relevant state. Args: entity: The GHOPTask entity """""" properties = { 'user': None, 'student': None, 'status': 'Reopened', 'deadline': None, } changes = [ugettext('User-MelangeAutomatic'), ugettext('Action-Forcibly reopened'), ugettext('Status-Reopened')] update_dict = { 'properties': properties, 'changes': changes, 'content': None, } return update_dict def delete(self, entity): """"""Delete existing entity from datastore. """""" def task_delete_txn(entity): """"""Performs all necessary operations in a single transaction when a task is deleted. """""" to_delete = [] to_delete += ghop_comment_logic.logic.getForFields(ancestors=[entity]) to_delete += [entity] db.delete(to_delete) self.tags_service.removeAllTagsForEntity(entity) db.run_in_transaction(task_delete_txn, entity) logic = Logic() ",MatthewWilkes/mw4068-packaging,src/melange/src/soc/modules/ghop/logic/models/task.py,Python,apache-2.0,14298 6,"/*============================================================================ bandwidth, a benchmark to estimate memory transfer bandwidth. Copyright (C) 2005-2017 by Zack T Smith. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program 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 for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA The author may be reached at 1@zsmith.co. *===========================================================================*/ //--------------------------------------------------------------------------- // Change log // 0.18 Grand unified version supports x86/intel64/arm, linux/win32/winmo. // 0.19 Now have 128-bit writer that goes to cache AND one that bypasses. // 0.20 Added my bmplib and graphing of output. Also added --slow option. // 0.21 Adds random testing. Min chunk size = 256 B. Allows non-2^n chunks. // 0.22 Adds register-to-register and register-to/from-stack transfers. // 0.23 Adds vector-to-vector and register-to-vector transfers, & Mac support. // 0.24 Adds network bandwidth tests from this PC to specified others. // 0.25 Made network tests bidirectional to test asymmetric networks. // 0.26 Fixes to prevent certain vector instructions being used w/AMD chips. // 0.27 Added 128-byte tests for greater precision. // 0.28 Added use of CPUID. // 0.29 Added more 128-byte tests. // 0.30 Adds cache identification for Intel CPUs in 64-bit mode. // 0.31 Adds cache identification for Intel CPUs in 32-bit mode. // 0.32 Added AVX support. // 1.0 Moved graphing logic into BMPGraphing. Added LODS support. // 1.1 Switched to larger font in graphing module. // 1.2 Re-added ARM 32 support. // 1.3 Added CSV output support. Added 32-bit Raspberry π 3 support. // 1.4 Added 256-bit routines RandomReaderAVX, RandomWriterAVX. // 1.4.1 Added --limit parameter. // 1.4.2 Fixed compiler warnings. // 1.5 Fixed AVX writer bug that gave inaccurate results. Added nice mode. // 1.5.1 Fixed crashing bug. //--------------------------------------------------------------------------- #ifndef _DEFS_H #define _DEFS_H #define RELEASE ""1.5.1"" #ifdef __WIN32__ typedef char bool; enum { true=1, false=0 }; #else #include #endif #define NETWORK_DEFAULT_PORTNUM (49000) #define NETSIZE_MIN (15) #define NETSIZE_MAX (28) #define NETWORK_CHUNK_SIZE (1< # # Browsershots is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. # # Browsershots 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 for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . """""" GUI-specific interface functions for X11. """""" __revision__ = ""$Rev: 2248 $"" __date__ = ""$Date: 2007-10-26 15:46:36 +0530 (Fri, 26 Oct 2007) $"" __author__ = ""$Author: johann $"" from shotfactory04.gui.linux import firefox as base class Gui(base.Gui): """""" Special functions for Mozilla Bon Echo. """""" pass ",mintuhouse/shotfactory,shotfactory04/gui/linux/bonecho.py,Python,gpl-3.0,1091 8,"//############################################################################# //# # //# Copyright (C) <2014> # //# # //# This program is free software: you can redistribute it and/or modify # //# it under the terms of the GNU Affero General Public License as # //# published by the Free Software Foundation, either version 3 of the # //# License, or (at your option) any later version. # //# # //# This program 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 Affero General Public License for more details. # //# # //# You should have received a copy of the GNU Affero General Public License # //# along with this program. If not, see . # //# # //############################################################################# //#EOH // This code was generated by Barbara Worwood using IMS Development Environment (version 1.80 build 5007.25751) // Copyright (C) 1995-2014 IMS MAXIMS. All rights reserved. // WARNING: DO NOT MODIFY the content of this file package ims.careuk.vo; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.Iterator; import ims.framework.enumerations.SortOrder; /** * Linked to CAREUK.TCIOutcomeForPatientElectiveList business object (ID: 1096100068). */ public class TCIOutcomeForAppointmentDNAVoCollection extends ims.vo.ValueObjectCollection implements ims.vo.ImsCloneable, Iterable { private static final long serialVersionUID = 1L; private ArrayList col = new ArrayList(); public String getBoClassName() { return ""ims.careuk.domain.objects.TCIOutcomeForPatientElectiveList""; } public boolean add(TCIOutcomeForAppointmentDNAVo value) { if(value == null) return false; if(this.col.indexOf(value) < 0) { return this.col.add(value); } return false; } public boolean add(int index, TCIOutcomeForAppointmentDNAVo value) { if(value == null) return false; if(this.col.indexOf(value) < 0) { this.col.add(index, value); return true; } return false; } public void clear() { this.col.clear(); } public void remove(int index) { this.col.remove(index); } public int size() { return this.col.size(); } public int indexOf(TCIOutcomeForAppointmentDNAVo instance) { return col.indexOf(instance); } public TCIOutcomeForAppointmentDNAVo get(int index) { return this.col.get(index); } public boolean set(int index, TCIOutcomeForAppointmentDNAVo value) { if(value == null) return false; this.col.set(index, value); return true; } public void remove(TCIOutcomeForAppointmentDNAVo instance) { if(instance != null) { int index = indexOf(instance); if(index >= 0) remove(index); } } public boolean contains(TCIOutcomeForAppointmentDNAVo instance) { return indexOf(instance) >= 0; } public Object clone() { TCIOutcomeForAppointmentDNAVoCollection clone = new TCIOutcomeForAppointmentDNAVoCollection(); for(int x = 0; x < this.col.size(); x++) { if(this.col.get(x) != null) clone.col.add((TCIOutcomeForAppointmentDNAVo)this.col.get(x).clone()); else clone.col.add(null); } return clone; } public boolean isValidated() { for(int x = 0; x < col.size(); x++) if(!this.col.get(x).isValidated()) return false; return true; } public String[] validate() { return validate(null); } public String[] validate(String[] existingErrors) { if(col.size() == 0) return null; java.util.ArrayList listOfErrors = new java.util.ArrayList(); if(existingErrors != null) { for(int x = 0; x < existingErrors.length; x++) { listOfErrors.add(existingErrors[x]); } } for(int x = 0; x < col.size(); x++) { String[] listOfOtherErrors = this.col.get(x).validate(); if(listOfOtherErrors != null) { for(int y = 0; y < listOfOtherErrors.length; y++) { listOfErrors.add(listOfOtherErrors[y]); } } } int errorCount = listOfErrors.size(); if(errorCount == 0) return null; String[] result = new String[errorCount]; for(int x = 0; x < errorCount; x++) result[x] = (String)listOfErrors.get(x); return result; } public TCIOutcomeForAppointmentDNAVoCollection sort() { return sort(SortOrder.ASCENDING); } public TCIOutcomeForAppointmentDNAVoCollection sort(boolean caseInsensitive) { return sort(SortOrder.ASCENDING, caseInsensitive); } public TCIOutcomeForAppointmentDNAVoCollection sort(SortOrder order) { return sort(new TCIOutcomeForAppointmentDNAVoComparator(order)); } public TCIOutcomeForAppointmentDNAVoCollection sort(SortOrder order, boolean caseInsensitive) { return sort(new TCIOutcomeForAppointmentDNAVoComparator(order, caseInsensitive)); } @SuppressWarnings(""unchecked"") public TCIOutcomeForAppointmentDNAVoCollection sort(Comparator comparator) { Collections.sort(col, comparator); return this; } public ims.careuk.vo.TCIOutcomeForPatientElectiveListRefVoCollection toRefVoCollection() { ims.careuk.vo.TCIOutcomeForPatientElectiveListRefVoCollection result = new ims.careuk.vo.TCIOutcomeForPatientElectiveListRefVoCollection(); for(int x = 0; x < this.col.size(); x++) { result.add(this.col.get(x)); } return result; } public TCIOutcomeForAppointmentDNAVo[] toArray() { TCIOutcomeForAppointmentDNAVo[] arr = new TCIOutcomeForAppointmentDNAVo[col.size()]; col.toArray(arr); return arr; } public Iterator iterator() { return col.iterator(); } @Override protected ArrayList getTypedCollection() { return col; } private class TCIOutcomeForAppointmentDNAVoComparator implements Comparator { private int direction = 1; private boolean caseInsensitive = true; public TCIOutcomeForAppointmentDNAVoComparator() { this(SortOrder.ASCENDING); } public TCIOutcomeForAppointmentDNAVoComparator(SortOrder order) { if (order == SortOrder.DESCENDING) { direction = -1; } } public TCIOutcomeForAppointmentDNAVoComparator(SortOrder order, boolean caseInsensitive) { if (order == SortOrder.DESCENDING) { direction = -1; } this.caseInsensitive = caseInsensitive; } public int compare(Object obj1, Object obj2) { TCIOutcomeForAppointmentDNAVo voObj1 = (TCIOutcomeForAppointmentDNAVo)obj1; TCIOutcomeForAppointmentDNAVo voObj2 = (TCIOutcomeForAppointmentDNAVo)obj2; return direction*(voObj1.compareTo(voObj2, this.caseInsensitive)); } public boolean equals(Object obj) { return false; } } public ims.careuk.vo.beans.TCIOutcomeForAppointmentDNAVoBean[] getBeanCollection() { return getBeanCollectionArray(); } public ims.careuk.vo.beans.TCIOutcomeForAppointmentDNAVoBean[] getBeanCollectionArray() { ims.careuk.vo.beans.TCIOutcomeForAppointmentDNAVoBean[] result = new ims.careuk.vo.beans.TCIOutcomeForAppointmentDNAVoBean[col.size()]; for(int i = 0; i < col.size(); i++) { TCIOutcomeForAppointmentDNAVo vo = ((TCIOutcomeForAppointmentDNAVo)col.get(i)); result[i] = (ims.careuk.vo.beans.TCIOutcomeForAppointmentDNAVoBean)vo.getBean(); } return result; } public static TCIOutcomeForAppointmentDNAVoCollection buildFromBeanCollection(java.util.Collection beans) { TCIOutcomeForAppointmentDNAVoCollection coll = new TCIOutcomeForAppointmentDNAVoCollection(); if(beans == null) return coll; java.util.Iterator iter = beans.iterator(); while (iter.hasNext()) { coll.add(((ims.careuk.vo.beans.TCIOutcomeForAppointmentDNAVoBean)iter.next()).buildVo()); } return coll; } public static TCIOutcomeForAppointmentDNAVoCollection buildFromBeanCollection(ims.careuk.vo.beans.TCIOutcomeForAppointmentDNAVoBean[] beans) { TCIOutcomeForAppointmentDNAVoCollection coll = new TCIOutcomeForAppointmentDNAVoCollection(); if(beans == null) return coll; for(int x = 0; x < beans.length; x++) { coll.add(beans[x].buildVo()); } return coll; } } ",open-health-hub/openmaxims-linux,openmaxims_workspace/ValueObjects/src/ims/careuk/vo/TCIOutcomeForAppointmentDNAVoCollection.java,Java,agpl-3.0,8921 9,"/* * Copyright (c) 1997 - 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include ""der_locl.h"" RCSID(""$Id: der_copy.c,v 1.1.1.1 2011/06/10 09:34:42 andrew Exp $""); int der_copy_general_string (const heim_general_string *from, heim_general_string *to) { *to = strdup(*from); if(*to == NULL) return ENOMEM; return 0; } int der_copy_utf8string (const heim_utf8_string *from, heim_utf8_string *to) { return der_copy_general_string(from, to); } int der_copy_printable_string (const heim_printable_string *from, heim_printable_string *to) { return der_copy_general_string(from, to); } int der_copy_ia5_string (const heim_printable_string *from, heim_printable_string *to) { return der_copy_general_string(from, to); } int der_copy_bmp_string (const heim_bmp_string *from, heim_bmp_string *to) { to->length = from->length; to->data = malloc(to->length * sizeof(to->data[0])); if(to->length != 0 && to->data == NULL) return ENOMEM; memcpy(to->data, from->data, to->length * sizeof(to->data[0])); return 0; } int der_copy_universal_string (const heim_universal_string *from, heim_universal_string *to) { to->length = from->length; to->data = malloc(to->length * sizeof(to->data[0])); if(to->length != 0 && to->data == NULL) return ENOMEM; memcpy(to->data, from->data, to->length * sizeof(to->data[0])); return 0; } int der_copy_visible_string (const heim_visible_string *from, heim_visible_string *to) { return der_copy_general_string(from, to); } int der_copy_octet_string (const heim_octet_string *from, heim_octet_string *to) { to->length = from->length; to->data = malloc(to->length); if(to->length != 0 && to->data == NULL) return ENOMEM; memcpy(to->data, from->data, to->length); return 0; } int der_copy_heim_integer (const heim_integer *from, heim_integer *to) { to->length = from->length; to->data = malloc(to->length); if(to->length != 0 && to->data == NULL) return ENOMEM; memcpy(to->data, from->data, to->length); to->negative = from->negative; return 0; } int der_copy_oid (const heim_oid *from, heim_oid *to) { to->length = from->length; to->components = malloc(to->length * sizeof(*to->components)); if (to->length != 0 && to->components == NULL) return ENOMEM; memcpy(to->components, from->components, to->length * sizeof(*to->components)); return 0; } int der_copy_bit_string (const heim_bit_string *from, heim_bit_string *to) { size_t len; len = (from->length + 7) / 8; to->length = from->length; to->data = malloc(len); if(len != 0 && to->data == NULL) return ENOMEM; memcpy(to->data, from->data, len); return 0; } ",ghmajx/asuswrt-merlin,release/src/router/samba-3.5.8/source4/heimdal/lib/asn1/der_copy.c,C,gpl-2.0,4326