jdk-sandbox: comparison jdk/src/share/classes/sun/tools/jconsole/inspector/Utils.java

equal deleted inserted replaced

-:a007508f7193
+:5ecee29e98d8
 /*
-* Copyright 2004-2006 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright 2004-2007 Sun Microsystems, Inc.  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.  Sun designates this
 import java.awt.event.*;
 import java.lang.reflect.*;
 import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.util.*;
+import java.util.concurrent.ExecutionException;
 import javax.management.*;
 import javax.management.openmbean.*;
 import javax.swing.*;
 import javax.swing.text.*;
-import java.util.*;
 public class Utils {
 private Utils() {
 }
 private static Set<Integer> tableNavigationKeys =
-new HashSet<Integer>(Arrays.asList(new Integer[] {
+new HashSet<Integer>(Arrays.asList(new Integer[]{
 KeyEvent.VK_TAB, KeyEvent.VK_ENTER,
 KeyEvent.VK_HOME, KeyEvent.VK_END,
 KeyEvent.VK_LEFT, KeyEvent.VK_RIGHT,
 KeyEvent.VK_UP, KeyEvent.VK_DOWN,
-KeyEvent.VK_PAGE_UP, KeyEvent.VK_PAGE_DOWN}));
+KeyEvent.VK_PAGE_UP, KeyEvent.VK_PAGE_DOWN
+}));
 private static final Set<Class<?>> primitiveWrappers =
-new HashSet<Class<?>>(Arrays.asList(new Class<?>[] {
+new HashSet<Class<?>>(Arrays.asList(new Class<?>[]{
 Byte.class, Short.class, Integer.class, Long.class,
-Float.class, Double.class, Character.class, Boolean.class}));
+Float.class, Double.class, Character.class, Boolean.class
+}));
 private static final Set<Class<?>> primitives = new HashSet<Class<?>>();
 private static final Map<String, Class<?>> primitiveMap =
 new HashMap<String, Class<?>>();
 private static final Map<String, Class<?>> primitiveToWrapper =
 new HashMap<String, Class<?>>();
 private static final Set<String> editableTypes = new HashSet<String>();
 private static final Set<Class<?>> extraEditableClasses =
-new HashSet<Class<?>>(Arrays.asList(new Class<?>[] {
+new HashSet<Class<?>>(Arrays.asList(new Class<?>[]{
 BigDecimal.class, BigInteger.class, Number.class,
-String.class, ObjectName.class}));
+String.class, ObjectName.class
+}));
 private static final Set<String> numericalTypes = new HashSet<String>();
 private static final Set<String> extraNumericalTypes =
-new HashSet<String>(Arrays.asList(new String[] {
+new HashSet<String>(Arrays.asList(new String[]{
 BigDecimal.class.getName(), BigInteger.class.getName(),
-Number.class.getName()}));
+Number.class.getName()
+}));
 private static final Set<String> booleanTypes =
-new HashSet<String>(Arrays.asList(new String[] {
+new HashSet<String>(Arrays.asList(new String[]{
-Boolean.TYPE.getName(), Boolean.class.getName()}));
+Boolean.TYPE.getName(), Boolean.class.getName()
+}));
 static {
 // compute primitives/primitiveMap/primitiveToWrapper
 for (Class<?> c : primitiveWrappers) {
 try {
 /**
 * This method returns the class matching the name className.
 * It's used to cater for the primitive types.
 */
 public static Class<?> getClass(String className)
 throws ClassNotFoundException {
 Class<?> c;
-if ((c = primitiveMap.get(className)) != null)
+if ((c = primitiveMap.get(className)) != null) {
 return c;
+}
 return Class.forName(className);
 }
 /**
 * Check if the given collection is a uniform collection of the given type.
 /**
 * Check if the given element denotes a supported array-friendly data
 * structure, i.e. a data structure jconsole can render as an array.
 */
 public static boolean canBeRenderedAsArray(Object elem) {
-if (isSupportedArray(elem)) return true;
+if (isSupportedArray(elem)) {
+return true;
+}
 if (elem instanceof Collection) {
 Collection<?> c = (Collection<?>) elem;
 if (c.isEmpty()) {
 // Empty collections of any Java type are not handled as arrays
 //
 // - Collections of CompositeData/TabularData are not handled
 //   as arrays
 // - Collections of other Java types are handled as arrays
 //
 return !isUniformCollection(c, CompositeData.class) &&
 !isUniformCollection(c, TabularData.class);
 }
 }
 if (elem instanceof Map) {
 return !(elem instanceof TabularData);
 }
 * n-times "[]" where 'n' denotes the arity of the array. Otherwise, if
 * the supplied name doesn't denote an array it returns the same classname.
 */
 public static String getReadableClassName(String name) {
 String className = getArrayClassName(name);
-if (className == null) return name;
+if (className == null) {
+return name;
+}
 int index = name.lastIndexOf("[");
 StringBuilder brackets = new StringBuilder(className);
 for (int i = 0; i <= index; i++) {
 brackets.append("[]");
 }
 /**
 * Try to create a Java object using a one-string-param constructor.
 */
 public static Object newStringConstructor(String type, String param)
 throws Exception {
 Constructor c = Utils.getClass(type).getConstructor(String.class);
 try {
 return c.newInstance(param);
 } catch (InvocationTargetException e) {
 Throwable t = e.getTargetException();
 /**
 * Try to convert a string value into a numerical value.
 */
 private static Number createNumberFromStringValue(String value)
 throws NumberFormatException {
 final String suffix = value.substring(value.length() - 1);
 if ("L".equalsIgnoreCase(suffix)) {
 return Long.valueOf(value.substring(0, value.length() - 1));
 }
 if ("F".equalsIgnoreCase(suffix)) {
 return Double.valueOf(value.substring(0, value.length() - 1));
 }
 try {
 return Integer.valueOf(value);
 } catch (NumberFormatException e) {
 // OK: Ignore exception...
 }
 try {
 return Long.valueOf(value);
 } catch (NumberFormatException e1) {
 // OK: Ignore exception...
 }
 try {
 return Double.valueOf(value);
 } catch (NumberFormatException e2) {
 // OK: Ignore exception...
 }
 throw new NumberFormatException("Cannot convert string value '" +
 value + "' into a numerical value");
 }
 * using the "value" parameter.
 * e.g. calling createObjectFromString("java.lang.Integer", "10")
 * will return an Integer object initialized to 10.
 */
 public static Object createObjectFromString(String type, String value)
 throws Exception {
 Object result;
 if (primitiveToWrapper.containsKey(type)) {
 if (type.equals(Character.TYPE.getName())) {
 result = new Character(value.charAt(0));
 } else {
 /**
 * This method is responsible for converting the inputs given by the user
 * into a useful object array for passing into a parameter array.
 */
 public static Object[] getParameters(XTextField[] inputs, String[] params)
 throws Exception {
 Object result[] = new Object[inputs.length];
 Object userInput;
 for (int i = 0; i < inputs.length; i++) {
 userInput = inputs[i].getValue();
 // if it's already a complex object, use the value
 /**
 * If the exception is wrapped, unwrap it.
 */
 public static Throwable getActualException(Throwable e) {
+if (e instanceof ExecutionException) {
+e = e.getCause();
+}
 if (e instanceof MBeanException ||
 e instanceof RuntimeMBeanException ||
 e instanceof RuntimeOperationsException ||
 e instanceof ReflectionException) {
 Throwable t = e.getCause();
-if (t != null) return t;
+if (t != null) {
+return t;
+}
 }
 return e;
 }
 @SuppressWarnings("serial")
 public static class ReadOnlyTableCellEditor
 extends DefaultCellEditor {
 public ReadOnlyTableCellEditor(JTextField tf) {
 super(tf);
 tf.addFocusListener(new Utils.EditFocusAdapter(this));
 tf.addKeyListener(new Utils.CopyKeyAdapter());
 }
 }
 public static class EditFocusAdapter extends FocusAdapter {
 private CellEditor editor;
 public EditFocusAdapter(CellEditor editor) {
 this.editor = editor;
 }
+@Override
 public void focusLost(FocusEvent e) {
 editor.stopCellEditing();
 }
-};
+}
 public static class CopyKeyAdapter extends KeyAdapter {
 private static final String defaultEditorKitCopyActionName =
 DefaultEditorKit.copyAction;
 private static final String transferHandlerCopyActionName =
 (String) TransferHandler.getCopyAction().getValue(Action.NAME);
+@Override
 public void keyPressed(KeyEvent e) {
 // Accept "copy" key strokes
 KeyStroke ks = KeyStroke.getKeyStroke(
 e.getKeyCode(), e.getModifiers());
 JComponent comp = (JComponent) e.getSource();
 // Accept JTable navigation key strokes
 if (!tableNavigationKeys.contains(e.getKeyCode())) {
 e.consume();
 }
 }
+@Override
 public void keyTyped(KeyEvent e) {
 e.consume();
 }
 }
 }

changeset 55	5ecee29e98d8
parent 2	90ce3da70b43
child 715	f16baef3a20e